Docs · The doctrine · Section 05
Runtime topology of an agentic system
Stripped of its stack, a running agentic system always keeps the same silhouette. Its components are stable; only their language and their partitioning vary, according to the preceding sections.
Runtime diagram
Reading the diagram
- Orchestrator: drives the loop, plans, delegates, synthesizes. It contains no business logic; it composes.
- Tool registry plus middleware: the single surface through which logging, access control, metrics, cost, and approvals pass. Adding a guardrail happens here, without touching the tools. It is also from here that a single trace stream is emitted, consumed separately by provenance, evaluation, and observability. This surface carries only cross-cutting concerns, never orchestration or business logic: it is the guard against the pitfall of the bloated integration bus of service-oriented architectures, where the channel ends up deciding the business. The logic stays in the tools and the orchestrator; the channel that connects them remains thin, and the registry remains an index, not a brain.
- Secondary ports: model (via a gateway that centralizes governance and tier-based routing), persistence, execution (often a specialized sidecar), input sources.
- Exposed tool server: the system publishes its use cases as standardized tools, so it can be driven by an external orchestrator without copying logic.
- Cross-cutting observability: every step leaves a trace usable after the fact, and that trace feeds continuous evaluation, not just a dashboard.
The sidecar as a recurring pattern
A specialized capability (for example an execution engine driven by another language) runs in a session-scoped sidecar, consumed via the tool protocol. The sidecar is treated as an external dependency: health monitored, circuit breaker in case of unavailability, documented restart procedure. The rest of the system keeps running in degraded mode if the sidecar goes down.
The registry, a port with two adapters
Discovering which tools and which sub-agents are available is, like everything else, an adapter decision. As long as everything lives in a single process, the registry is a simple in-memory table, atomic and free. As soon as a capability moves out of the process, comes from another language, or from another team, the same port switches to a service discovery adapter: each agent publishes a self-describing capability card, discovered via a shared registry, by announce and subscribe with a local cache, never by a central call at every iteration. The discovery contract does not change; only the adapter changes with the topology.