Agent Orchestration

Historical synthesis preserved from the August 2026 source captures. The September reconciliation checks identifiers and provenance; time-sensitive claims have not been freshly re-verified.

The discipline of coordinating multiple AI agents — each with their own role, context, and tools — so they collectively achieve a higher-level goal. Distinct from running a single agent in a chat loop: orchestration adds routing, task queues, shared state, and coordination primitives.

2026 enterprise update

Production orchestration is increasingly a durable execution problem: checkpoints, idempotent tool calls, typed hand-offs, timeouts, compensation, human approval and replay matter more than conversational role-play [src-251, src-252]. Multi-agent topologies should be selected only when decomposition creates independent work, permission separation or useful parallelism. Research finds that sequential dependencies, correlated errors and coordination overhead can make a well-designed single agent more accurate and cheaper [src-256, src-257, src-258].

See Enterprise Agent Platform Stack and the 2026 platform comparison.

Key points

• The core orchestration problem is visibility and coordination at scale: when you have 5-20 agents running concurrently, you can't track them in individual terminal windows. You need a dashboard, a ticketing system, and a shared task queue. Paperclip was built explicitly to solve this pain point ^[src-001].

• Orchestration patterns differ by who is in charge. Three options:

– Human-first: user prompts each agent individually; the orchestrator is a multiplexer.

– Lead agent-first: one "CEO" or "planner" agent delegates to worker agents. This is Paperclip's model.

– Event-first: agents wake up on schedule or triggers (heartbeats, webhooks) and check their task queue. This is Openclaw's original model, now part of Paperclip.

• Good orchestration requires per-agent instruction files so agents have stable identity and priorities across resets. Paperclip uses 4 files per agent: agents.md (context), heartbeat.md (what to do on wake), soul.md (persona), tools.md (capabilities) ^[src-001].

• Budget and model-per-agent become first-class concerns at scale. Not every agent needs to be Opus/Sonnet — designers and summarisers can run on cheaper models ^[src-001].

Related entities

• Paperclip — primary orchestration platform in this wiki
• Openclaw — earlier implementation that popularised heartbeats
• Claude Code — the underlying runtime Paperclip uses per agent

Orchestration as schema-driven work

The deeper pattern behind orchestration is encoding operational knowledge into a schema that the LLM follows autonomously ^[src-002]. Paperclip's per-agent files (agents.md, heartbeat.md, soul.md, tools.md) are a specialised case. Karpathy's CLAUDE.md for the LLM Knowledge Bases pattern is another. Robin's own CLAUDE.md (with 21+ active skills and their routing rules) is a third. In each case, the schema file IS the product specification for an AI colleague.

This is why orchestration and knowledge-management look structurally similar: both require a durable declaration of "here is how you, the LLM, should operate when I'm not watching."

The agentic mechanism underneath

Each orchestrated agent is itself running the React Loop ^[src-003]. Orchestration doesn't replace the ReAct loop — it coordinates multiple ReAct loops that communicate through a shared task queue, ticketing system, or file system. The mechanism at the atomic level is the same; the orchestration layer is the coordination protocol on top.

Google's A2UI v0.9 post adds two interface-adjacent orchestration pieces. A2A provides a transport for remote agents communicating with agents or frontends, while A2ui defines the UI the user touches when an agent drives a client interface ^[src-038].

Google Cloud's enterprise-agent session adds an operations/governance view: as agents move from delegated workflows to autonomous agents and Dynamic Agent Swarms, orchestration needs identity, authority, traceability, policy enforcement, and real-time intervention, not only task routing ^[src-043].

Preston Holmes' Context Sharding frame treats multi-agent roles as focused context windows for sub-problems that are too large or heterogeneous for one agent context ^[src-043].

Next '26 productizes orchestration inside Gemini Enterprise Agent Platform with Agent-to-Agent Orchestration, graph-based ADK workflows, Agent Registry, Agent Marketplace, long-running agents, Memory Bank, Memory Profiles, and Agent Sessions ^[src-044].

Cursor's team-era demo is the software-development version of this orchestration problem: many agents with separate remote computers can work on different coding tasks in parallel, but the human and product layer still need task assignment, review, testing, and architecture control ^[src-080].

OpenAI's GPT Realtime 2 Build Hour adds a realtime voice orchestration pattern. A voice agent can route among UI tools, external APIs, dashboard tools, and background investigations while maintaining the spoken conversation; Sierra also describes supervisors that review an ongoing call asynchronously and inject context without forcing the model to answer immediately ^[src-083].

Related concepts

• Agentic AI
• React Loop
• Heartbeats
• Multi Agent Companies
• Zero Human Companies
• Agent Budget Controls
• LLM Knowledge Bases
• Model Context Protocol
• Agent To Agent Protocol
• A2ui
• Generative Ui
• Enterprise Agent Governance
• Context Sharding
• Dynamic Agent Swarms
• Semantic Contracts For Agents
• Gemini Enterprise Agent Platform
• Agentic Enterprise
• Coding Agent Team Era
• Voice To Action Interfaces
• Production Voice Agent Harness

Updates from bulk ingest

From src-007 (cluster 4)

• The 'single-brain' voice-agent principle: when orchestrating Vapi with n8n, the voice agent itself is the only reasoning layer; back-end workflows should remain deterministic to avoid doubling latency, cost and error surface. A concrete counter-example to multi-agent composition in real-time voice contexts (y-cq_Qo4zVo)

Source references

• ^[src-001] Nate Herk — "Claude Code + Paperclip Just Destroyed OpenClaw" (2026-03-28)
• ^[src-002] Robin Cartier — "Karpathy's LLM Knowledge Base: A Practitioner's Verdict" (2026-04-08)
• ^[src-003] Robin Cartier — "What is Agentic AI? A Complete Guide" (2026-03-10)
• ^[src-007] Nate Herk cluster (see summaries/src-007-*.md)
• ^[src-038] Google A2UI Team — "A2UI v0.9: The New Standard for Portable, Framework-Agnostic Generative UI" (2026-04-17)
• ^[src-043] Google Cloud Events — "Operationalize AI: A blueprint for managing enterprise agents at scale" (2026-04-24)
• ^[src-044] Thomas Kurian — "Welcome to Google Cloud Next '26" (2026-04-22)
• ^[src-080] Cursor — "The next era of AI coding" (2026-05-12)
• ^[src-083] OpenAI – "Build Hour: GPT-Realtime-2" (2026-05-13)

2026-07-01 ADK Go 2.0 graph workflows

• ADK for Go 2.0 adds graph-based workflows, typed nodes, routing, fan-out/fan-in, human-in-the-loop primitives, and a unified node runtime, reinforcing explicit orchestration graphs as a production-agent pattern ^[src-194].

2026-08-06 orchestration updates

• Claude Code's dynamic workflows use sequential and parallel agents as task-time compute, but the agent count and topology remain subordinate to verification and task structure ^[src-414].
• Jeff Dean describes context engineering, skills, tools, and orchestration as a capability layer that can matter as much as the base model ^[src-416].
• Alexandr Wang argues that systems thinking, agent orchestration, and precise metrics become more valuable as model intelligence and execution capacity grow ^[src-417].

Evidence checked on 14 September 2026

Google Cloud Tech teaches graph workflows using a marathon race-planning example: use deterministic functions for fetching known inputs and reserve the model for reasoning over those inputs. ^[src-483] Manual en-US captions replaced the initial automatic transcript for higher source fidelity. Code/API version behavior was described by the tutorial; no local ADK execution was performed.

• Graph Engineering with ADK