Orchestrate AI agents that call each other, in Python, Go or TS
How AgentField lets agents in Python, TypeScript and Go discover and call each other through a control plane, with shared memory and one workflow trace.
To orchestrate AI agents that call each other, pick between an in-process framework, where every agent lives in one program, and a control plane, where each agent is its own service and calls go through a router that handles discovery, policy and tracing; AgentField is an open-source (Apache 2.0) control plane of the second kind, with SDKs in Python, TypeScript and Go, and one call shape, app.call("node.function"). If all your agents ship together in one Python app, a framework is simpler. If different teams, languages or deploy schedules are involved, you want the control plane.
At a glance
| Option | Agents are | Languages | Cross-agent calls | Licence |
|---|---|---|---|---|
| AgentField | Separate services (nodes) registered with a control plane | Python, TypeScript, Go | app.call("node.function") over the control plane | Apache 2.0 |
| LangGraph | Nodes in a stateful graph, in one process | Python, JavaScript/TypeScript | Graph edges and shared state | MIT |
| CrewAI | Crews of role-based agents, plus event-driven Flows | Python | Within a crew or flow | MIT |
| Microsoft Agent Framework | Agents and workflows; successor to Semantic Kernel and AutoGen | .NET and Python stable, Go in preview | Workflows and orchestration patterns | MIT |
| Google ADK | Agent hierarchies in one app | Python, Java, Go, TypeScript, Kotlin | Sub-agents and agent tools | Apache 2.0 |
| A2A protocol | Any agents, across vendors | Protocol, not an SDK | Agent-to-agent messages over a standard | Open protocol, Linux Foundation |
How a cross-agent call works in AgentField
Each agent is a node with a node_id. A caller names the target, not a URL. From the cross-agent calls docs:
@app.reasoner()
async def triage_ticket(ticket_id: str, message: str, customer_id: str) -> dict:
sentiment = await app.call("sentiment-agent.analyze_text", text=message)
history = await app.call("customer-history.recent_issues", customer_id=customer_id)
if sentiment["urgency"] == "high" or history["issue_count"] > 3:
escalation = await app.call(
"escalation-agent.create_case",
ticket_id=ticket_id,
reason="high urgency or repeated incidents",
)
await app.call("notifications.send_alert", case_id=escalation["case_id"])
app.note(f"Escalated ticket {ticket_id} to {escalation['case_id']}", ["triage", "escalation"])
return {"status": "escalated", "case_id": escalation["case_id"]}
return {"status": "queued", "sentiment": sentiment, "history": history}The same call in Go is a.Call(ctx, "sentiment-agent.analyze_text", map[string]any{"text": input["message"]}), and in TypeScript agent.call('sentiment-agent.analyzeText', { text }). That is the point of one target format: a TypeScript product agent can call a Python model agent or a Go platform agent without a client library for each.
On every call the SDK forwards X-Run-ID, X-Workflow-ID, X-Parent-Execution-ID, X-Session-ID, X-Actor-ID and X-Caller-DID. You never set them; they are how the control plane builds the workflow graph. When the target is on the same agent, the call skips the network.
Discovery: find agents at runtime
Hard-coded addresses break once you pass a handful of agents. Service discovery lets an orchestrator ask what is live:
caps = app.discover(
tags=["public"],
health_status="active",
include_input_schema=True,
format="json",
)Pass tools="discover" to app.ai(...) and the model can pick and call a discovered capability as a tool. New agents register at startup and appear without a config change.
Shared memory and one trace
Agents coordinate through shared memory with four scopes: global, session, actor and workflow. await app.memory.set("ticket:T-123.sentiment", {...}) in one agent is readable by another in the same workflow, and Python and TypeScript agents can react to changes (@app.on_change("ticket:*:sentiment")); the Go SDK does not support memory events. Every call becomes a node in one workflow DAG, queryable at GET /api/ui/v1/workflows/{workflowId}/dag, and af share <run-id> exports it as an HTML file.
MCP and A2A, as far as the docs go
AgentField is an MCP client: af add --mcp --url <server> registers a server, and each of its tools becomes a skill named {server_alias}_{tool_name} that any agent can app.call. For agents outside your deployment, external agent discovery publishes selected capabilities at /.well-known/ai-catalog.json and can import outside entries, with OpenAPI, MCP or A2A listed as the invocation adapter. Imports are callable only after an operator creates an explicit external.* binding. Inside one control plane, agents talk with app.call, not A2A.
Honest limits: every hop goes through the control plane, which the README puts at roughly 100 to 200 ms, so a design with many tiny hops is slower than function calls inside one framework process. The ecosystem of prebuilt agents and integrations around LangGraph and CrewAI is larger than ours.
When something else fits better
- One team, one Python app, a graph you want to reason about. LangGraph's explicit state graph is excellent for that, and it now has a JavaScript version.
- Role-based teams of agents with little infrastructure. CrewAI's Crews and Flows get a collaborating team running quickly.
- A .NET shop, or existing AutoGen code. AutoGen is archived and points new users to Microsoft Agent Framework, which reached 1.0 in April 2026 and has a migration guide.
- Agents built and deployed on Google Cloud. ADK has the widest language list here and deploys to Cloud Run and Google's agent runtime.
You can also combine them: a reasoner is a plain function, so a LangGraph graph or a CrewAI crew can run inside one and still be called, traced and governed as a node. See AgentField vs CrewAI and running agents as backend services.
Questions people ask
What platform should I use to orchestrate multiple AI agents that call each other?
If the agents ship together in one process, use a framework such as LangGraph or CrewAI. If they are separate services owned by different teams or written in different languages, use a control plane such as AgentField, where each agent registers and calls another with app.call("node.function"), with discovery, policy and tracing on every call.
Is there agent orchestration that works in Python, Go and TypeScript?
Yes. AgentField has first-class SDKs in all three, and agents in different languages call each other with the same node.function target through the control plane. Google ADK and Microsoft Agent Framework also span several languages, but their agents typically run inside one application.
Does AgentField support A2A?
Only at the edge, today. AgentField's external agent discovery lists A2A as one of the adapters for calling an imported outside agent, alongside OpenAPI and MCP. Agents inside one AgentField deployment communicate with app.call, not A2A.
Can AgentField agents use MCP tools?
Yes. AgentField is an MCP client: af add --mcp registers a server, and its tools become skills that any agent can discover, call and see traced like any other capability.
How do I see which agent called which?
Every cross-agent call adds an edge to the workflow DAG, with timing and status per node. Query GET /api/ui/v1/workflows/{workflowId}/dag, watch live events over SSE, or export a run with af share <run-id>.
Sources
- AgentField docs, checked 2026-11-21: cross-agent calls, discovery, shared memory, workflow tracing, MCP, external agent discovery, features
- Agent-Field/agentfield README, checked 2026-11-21 (hop overhead)
- LangGraph repo, CrewAI repo, Microsoft Agent Framework overview, Agent Framework 1.0 post, AutoGen repo, Google ADK repo, A2A protocol, checked 2026-11-21
Checked 2026-11-21 against the AgentField docs and each project's own documentation on that date.