Skip to content

Agent Concepts

An agent uses an LLM to decide what to do next, working in turns until a goal is met. The Agents & AI overview explains that loop. This page explains the concepts underneath: how Conductor represents an agent, how workflows and agents call each other, and the three ways to author one.

A workflow invokes an agent through the AGENT task A workflow reaches an AGENT task, which invokes a Conductor Agent compiled to a workflow graph of LLM turns and tool calls, or a remote A2A agent. The result returns to the workflow. Your workflow Task AGENT task invoke result Conductor Agent compiled to a workflow graph LLM turn Tool call loops until done or invoke remotely Remote A2A agent independently deployed service

Agents are workflows underneath

A Conductor Agent starts as a definition, just like a workflow. The definition names the model to use, the instructions, and the tools the agent may call. Here is that definition in the Python SDK:

from conductor.ai.agents import Agent, AgentRuntime, tool

@tool
def get_weather(city: str) -> str:
    return f"Weather for {city}"

agent = Agent(name="weather", model="openai/gpt-4o-mini",
              instructions="Answer concisely.", tools=[get_weather])
with AgentRuntime() as runtime:
    print(runtime.run(agent, "Weather in Seattle?").output)

When this runs, Conductor compiles the agent into a workflow graph and executes it. Nothing about that graph is special: each model call is a task, each tool call is a task, and the loop between them is workflow control flow. A run that calls the tool once produces this sequence of tasks:

%%{init: {'look': 'handDrawn', 'theme': 'base', 'themeVariables': {'primaryColor': '#eef2ff', 'primaryBorderColor': '#1e40af', 'primaryTextColor': '#1e293b', 'lineColor': '#1e3a8a', 'edgeLabelBackground': '#ffffff', 'clusterBkg': '#fbfcff', 'clusterBorder': '#2563eb', 'fontFamily': '-apple-system, system-ui, Segoe UI, Roboto, Helvetica, Arial, sans-serif', 'fontSize': '15px'}, 'flowchart': {'nodeSpacing': 50, 'rankSpacing': 58, 'padding': 14, 'htmlLabels': true, 'curve': 'basis'}}}%%
flowchart LR
    prompt(["prompt"]) --> turn1["LLM task<br/>decides to call get_weather"]
    turn1 --> toolcall["get_weather task<br/>runs your function"]
    toolcall --> turn2["LLM task<br/>writes the final answer"]
    turn2 --> answer(["answer"])

That design is the point. Because an agent run is a workflow execution, everything you know about workflows applies. Each turn is persisted, so a crash or restart resumes from the last completed step. Retries and timeouts follow the same policies. A person can approve or reject a step through the same human tasks. And every run leaves a complete history you can inspect and replay.

How workflows and agents compose

Workflows call agents through the AGENT task. To a parent workflow, an agent is one durable step: the workflow reaches the AGENT task, the agent runs its turns, and the result comes back as task output. In the workflow definition, it looks like any other task:

{
  "name": "run_agent",
  "taskReferenceName": "run_agent_ref",
  "type": "AGENT",
  "inputParameters": {
    "agentType": "conductor",
    "name": "planner",
    "prompt": "${workflow.input.prompt}"
  }
}

The same AGENT task can also point at a remote agent that speaks the Agent2Agent (A2A) protocol. In that case the agent's implementation stays remote, while Conductor durably tracks the handoff and its result.

Composition works in the other direction too. An agent's tools can be MCP tools or functions you register with the SDK, and each call runs as a task. So one process can mix ordinary tasks, native AI tasks, deployed agents, and remote agents in a single durable graph.

Three ways to author an agent

Which path you choose depends on where the behavior should live.

  • A declarative AI workflow puts the whole loop in the workflow definition itself, using native LLM, MCP, and control-flow tasks. Choose this when you want the complete orchestration visible and versioned as a workflow. Start with LLM orchestration.
  • A Conductor Agent is authored in code, with a Conductor SDK or a supported framework such as OpenAI Agents, LangChain, LangGraph, or Google ADK. Conductor compiles it to a workflow graph you deploy and reuse through the AGENT task. Choose this when the agent logic already lives in code. Start with Conductor Agents.
  • A remote A2A agent is a separate service you call through a durable AGENT task. Choose this when the agent is owned, deployed, and scaled outside Conductor. Start with A2A integration.

Take the next step

Build directlyCreate a native LLM, tool, and control-flow workflow. Bring existing agent codeRun a first SDK-authored Conductor Agent, then deploy it for workflow reuse. Integrate a remote agentCall or expose an A2A agent through a durable workflow boundary.