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
Two execution runtimes, plus an external identity model.
An agent is a first-class object with routes, resources, policy, usage, and health. Builtin and ACP agents execute through the gateway today; HTTP defines the external-agent shape while direct task dispatch remains on the roadmap.
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.
- Checkpointed approval Interactive MCP calls suspend without holding a slot, then resume under one stable run identity with linked trace segments.
- Operational control Retry transient model failures and force-cancel or gracefully stop an in-flight turn.
- Context middleware Opt into summarization, reduction, tool search, inline skills, plan tasks, and virtual AGENTS.md guidance.
- 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 — register your external agent
Agents built on any framework, running on your own infrastructure, can register an endpoint and management identity today. The task backend that invokes that endpoint is planned with gateway-owned external tasks.
- Same identity model Routes, resources, policy, usage, and health like every other runtime.
- Attribution references Bound route traffic is attributed when route ownership is unambiguous.
- Execution boundary The gateway stores and validates the identity today; it does not dispatch HTTP agent tasks.
- 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 | task backend roadmap | Conditional route attribution |
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 management shape: linked model and MCP resources, ingress routes, policy, and health. Builtin definitions additionally enforce their selected model route and tools at execution time.
- 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.
- Stable runtime switches One AgentRoute keeps its URL, route id, and VirtualKey allowlist when the runtime changes.
Publish an agent like an API
A builtin or ACP agent behind one runtime-neutral AgentRoute 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 Virtual-key and agent dimensions support per-consumer and per-agent usage queries.
- 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 coordinate inline sub-agents on one task — supervisor delegation, plan-execute loops, parallel fan-out — inside one governed turn. Independent ACP/HTTP/builtin agents require the workflow layer below.
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.