Agents & orchestration
Register. Expose. Assign. Coordinate.
The real problem isn't proxying a protocol — it's running agents as a managed workforce: register them, expose them safely, assign their models and tools, watch what they do, resolve human approvals, and coordinate work across agents. That is what the AgentGuide control plane is for.
Runtimes
Three ways to run an agent, one way to manage it.
An agent is a first-class object with routes, resources, policy, usage, and health — regardless of where its code executes. The runtime type only decides who owns the process.
Builtin — agents as configuration
Declare an agent — its model route, its MCP tools, its topology — and the gateway materializes it in-process on an embedded agent framework. No container to build, no service to deploy. Definition updates take effect on the next turn while in-flight work drains gracefully.
- Deepest observability Inner model calls and tool executions get their own traced spans under each turn.
- Governed by construction The agent's model goes through your LLM routes; its tools through your MCP services. It can't reach anything else.
- Fail-closed limits Per-agent concurrency caps and turn timeouts reject rather than queue; every turn runs under panic containment.
- Capability-aware brains Nodes that carry tools only bind tool-capable models; plan-execute roles can each run a different model — a cheap planner, a strong executor.
- Session continuity Same-session turns serialize safely, and a conversation being continued can never lose its history to capacity eviction.
- Custom Go agents Compile your own agent factory into the binary and select it declaratively.
ACP — managed coding agents
The gateway owns the lifecycle of Agent Client Protocol agents such as Codex and OpenCode: it pools processes, streams turns over SSE, replays transcripts, and routes permission requests through your policy — deny, auto-approve, or interactive human decision.
- Process pooling Idle reaping, instance caps, dead-instance eviction, session-aware reuse.
- Sessions & transcripts List sessions, replay full conversations, resume threads.
- Human-in-the-loop Permission requests surface on the live stream and resolve via API — with a fail-closed timeout.
- Streaming turn API Deltas, reasoning, plans, tool calls, and usage as typed SSE events.
HTTP — bring your own agent
Agents built on any framework, running on your own infrastructure, register for identity, routing, and attribution. Existing and external agents join the same control plane without being rewritten.
- Same identity model Routes, resources, policy, usage, and health like every other runtime.
- Same event stream Traffic the agent sends through the gateway is attributed back to it.
- No lock-in LangChain, ADK, custom stacks — the gateway doesn't care.
| Runtime | Process owner | Best for | Orchestration | Observability depth |
|---|---|---|---|---|
| Builtin | Gateway (in-process) | Composable enterprise agents, multi-agent topologies | declarative topologies | Turn + inner model & tool spans |
| ACP | Gateway (managed processes) | Coding agents: Codex, OpenCode | sessions & permissions | Turn events, transcripts, usage |
| HTTP | You (external service) | Existing agents on any framework | via gateway resources | Attributed gateway traffic |
Registry & publishing
Your agents, cataloged and productized.
Most organizations can't answer "what agents do we have, and who can call them?" AgentGuide makes both questions boring: a registry that inventories every agent, and routes that publish an agent as a governed API product.
One inventory of your agent estate
Every agent — builtin, ACP, or HTTP — is a registered object with a declared shape: which model routes it uses, which MCP tools it may touch, which routes expose it, whether it's healthy. The workspace view assembles it all on one page per agent.
- Declared capabilities Model and tool bindings are part of the agent's definition — discoverable, not tribal knowledge.
- Live state Materialization status, pooled instances, in-flight turns, pending approvals.
- Health & activity Per-agent health, usage rollups, and interaction history.
- Unambiguous ownership A route or runtime service belongs to at most one agent — attribution can't blur.
Publish an agent like an API
An agent behind a route is an enterprise capability with a stable endpoint: consumers get a URL and a virtual key; you keep versioned definitions, per-consumer metering, and the power to revoke access in one place. Ship agents to internal teams the way you ship services.
- Stable endpoints Streaming turn APIs behind gateway routes — consumers never touch the runtime.
- Keyed access Issue a virtual key per consuming team or app; rotate and revoke centrally.
- Metered usage Every consumer's traffic lands in the attributed event stream.
- Zero-downtime updates Builtin definition changes apply on the next turn while in-flight work drains.
Builtin topologies
Multi-agent patterns, declared not coded.
A builtin agent's topology is part of its definition. Compose sub-agents into proven coordination patterns — validated at configuration time, materialized at run time.
Single
One model, optional tools, optional conversation summarization.
Sequential
A pipeline of sub-agents, each refining the previous result.
Parallel
Fan work out across sub-agents and combine what comes back.
Loop
Iterate until the result converges or the bound is reached.
Supervisor
A tool-calling head that delegates to specialist sub-agents.
Plan-Execute
Planner, executor, and replanner roles — each can use a different model; only the executor carries tools.
Deep
A research-style head that recurses into sub-agents for depth.
Custom
Your own Go factory, compiled in and selected by name.
Workspaces & workflows
From single agents to a coordinated workforce.
The endgame is large, complex tasks delivered by multiple agents working together — with the gateway as the scheduler, the policy engine, and the flight recorder. This is the layer the whole platform builds toward.
Agent workspace
One pane of glass per agent: its definition and runtime state, live instances and in-flight turns, pending permission decisions, session and transcript references, linked model and tool resources, and its usage and interaction history.
Composed teams via topology
Builtin topologies already coordinate multiple agents on one task — supervisor delegation, plan-execute loops, parallel fan-out — inside one governed, fully traced turn.
Tasks & scheduling
Gateway-owned units of work: run an agent on a prompt now, resume a session, schedule recurring jobs, hand work from agent A to agent B — with durable state, retries, cancellation, and audit metadata.
Cross-agent workflows
Workflow definitions and runs spanning independent agents: hand-off and dependency semantics, topology views, and human checkpoints — enterprise missions decomposed across the whole fleet.
Human in the loop
Autonomy with an approval path.
Agent actions that matter — writing files, running commands, touching production — can require a human decision. Permission requests stream to the operator in real time and resolve through the API; no answer means no, every time. Deny by default, auto-approve where safe, ask where it counts.