Last updated · Santosh Kumar Radha

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

OptionAgents areLanguagesCross-agent callsLicence
AgentFieldSeparate services (nodes) registered with a control planePython, TypeScript, Goapp.call("node.function") over the control planeApache 2.0
LangGraphNodes in a stateful graph, in one processPython, JavaScript/TypeScriptGraph edges and shared stateMIT
CrewAICrews of role-based agents, plus event-driven FlowsPythonWithin a crew or flowMIT
Microsoft Agent FrameworkAgents and workflows; successor to Semantic Kernel and AutoGen.NET and Python stable, Go in previewWorkflows and orchestration patternsMIT
Google ADKAgent hierarchies in one appPython, Java, Go, TypeScript, KotlinSub-agents and agent toolsApache 2.0
A2A protocolAny agents, across vendorsProtocol, not an SDKAgent-to-agent messages over a standardOpen 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:

python
@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:

python
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

Checked 2026-11-21 against the AgentField docs and each project's own documentation on that date.