Why AgentGuide
A control plane, not another agent framework.
LangGraph, AutoGen, and CrewAI answer "how should an agent think?" AgentGuide answers a different question: "how does an organization run agents?" — who may call them, what they may touch, what they cost, and how they combine into larger capabilities. One builds agents. The other operates the agent estate.
The distinction
Frameworks orchestrate reasoning. AgentGuide orchestrates agents.
A framework's workflow lives inside one agent process: plan, call a tool, reflect, retry. AgentGuide's control lives outside the agent: lifecycle, scheduling, sessions, policy, attribution. The relationship is the one between a container runtime and Kubernetes — different layers, both needed.
| Agent frameworks (LangGraph, AutoGen, CrewAI…) |
AgentGuide (control plane) |
|
|---|---|---|
| Orchestrates | Reasoning steps inside one agent | Agents as units: lifecycle, routing, coordination |
| Sees the agent as | Code you write | A registered, governed black box behind a protocol |
| Core concerns | Prompts, memory, planning, reflection | Sessions, scheduling, policy, approvals, cost, audit |
| State lives | Inside the agent process | In the gateway: registry, events, transcripts, permissions |
| Analogy | The program | The operating system it runs on |
Keep your framework. Gain a control plane.
AgentGuide is deliberately not a competitor to your framework — it's where framework-built agents go to run in production. The builtin runtime itself embeds an agent framework for its topologies; the gateway's job stays the same either way: definition, lifecycle, governance, resources, and observation.
- Builtin runtime Declarative agents on an embedded framework — proof the two layers compose.
- ACP runtime Codex, OpenCode, and other protocol-speaking agents, managed as black boxes.
- HTTP runtime LangGraph, ADK, or custom services join with identity and attribution, unchanged.
- No rewrite tax Adopting the control plane never means rebuilding the agents.
The platform, layer by layer
An honest map of what ships today.
Six layers make up an enterprise agent platform. Here is where AgentGuide stands on each — what you can deploy now, what is being built, and where the platform is heading.
Declare target capabilities; the platform assembles the agents. Artifact contracts, capability graphs.
visionMulti-agent topologies inside one governed turn ship today; cross-agent tasks, scheduling, and workflows are on the roadmap.
shipping + expandingVirtual keys, permission gates with human approval, recursion-depth limits, fail-closed concurrency and timeouts.
shippingAttributed usage events for LLM/MCP/ACP/builtin traffic, interaction spans, Prometheus exposition.
shippingBuiltin in-process host, managed ACP lifecycles with sessions and transcripts, HTTP agent identity.
shippingLLM gateway with logical model routing and credential pooling; MCP gateway; protocol adapters.
shippingWhere this is going
From governed agents to an enterprise capability network.
The layers above are the foundation for a bigger idea: enterprises won't buy one agent, they'll operate an organization of them. These are the abstractions we're building toward — on the roadmap, not in the box today.
Work products, not prompt chains
Agents exchange versioned, auditable artifacts — a PRD, an architecture, a patch, a review — instead of raw text. Every artifact has a producer, consumers, versions, and an approval state, forming a lineage graph that answers "why did this fail?" in one query.
Ask for outcomes, not agents
Declare the capability you need — "review this contract", "release this service" — and let the platform resolve which agents combine to deliver it, wired together by the artifact types they consume and produce.
Invoke a team, not an agent
Named teams — PM, architect, coder, reviewer — as first-class objects with role routing and supervisor policy. The in-process supervisor and plan-execute topologies that ship today are the first step.
A blackboard for the fleet
Workspace-scoped memory that collaborating agents read and write — long-lived context that outlives any single session, governed like every other resource.
Start where the value is
The control plane pays off from the first agent.
You don't need a fleet to benefit: route one agent through AgentGuide and you get attribution, keys, and approvals on day one. The orchestration layers arrive on a foundation you already trust.