Agentic Orchestration: Running Multi-Agent Teams at Scale

The Coordination Problem

A single agent with a BIOS, validated capabilities, and self-built libraries can do excellent work in its domain. But real business operations don't happen in isolation.

Launching a product requires the content agent to write copy, the media buying agent to plan campaigns, the email agent to build sequences, the analytics agent to set up tracking, and the creative director agent to approve everything. These agents need to collaborate — hand off assets, share context, respect each other's domains, and resolve conflicts.

This is Step 9 of the Context-First methodology: Agentic Orchestration. It's the system that turns individual agents into coordinated teams.

AriaOS: The Kernel

AriaOS (Agent Routing and Intelligence Architecture Operating System) is the orchestration layer. Think of it as the kernel of an operating system — it doesn't do the work itself, but it routes tasks, manages resources, and ensures every agent operates within its defined boundaries.

The kernel handles four things:

1. Task Routing

When a project task comes in — "Launch the Spring Collection campaign" — the kernel decomposes it into domain-specific subtasks and routes each to the right agent:

• Brigid (content): Write collection descriptions, social posts, email copy
• Saoirse (media buying): Plan Meta campaign structure, set budgets, define audiences
• Niamh (customer engagement): Prepare customer notification sequences
• Fionn (analytics): Set up conversion tracking, define KPI targets
• Oisín (creative director): Review all creative for brand coherence

The routing isn't random. Each agent's Context Efficiency Index (from Step 7) tells the kernel what each agent can handle and at what autonomy tier it operates.

2. Context Passing

Agents need to share context without overloading each other. When Brigid produces product copy, Saoirse needs it for ad creative — but Saoirse doesn't need Brigid's full writing process, drafts, or revision history.

The kernel manages context packets — structured handoffs that contain:

• The output artifact (the copy itself)
• Relevant BIOS spec references (which constraints apply)
• Quality metadata (was this first-pass accepted? what confidence level?)
• Task context (what campaign is this for? what deadline?)

Context packets prevent the "telephone game" problem where information degrades as it passes between agents.

3. Conflict Resolution

Inevitably, agents disagree. Saoirse wants discount-led creative because the data shows higher CTR. Oisín refuses because the brand ethos prohibits hard-sell tactics. Who wins?

The kernel resolves conflicts using a constitutional hierarchy:

1. BIOS constraints always win over agent preferences
2. Restraint doctrine violations are automatic vetoes
3. Data-backed arguments outweigh intuition-based arguments
4. The creative director agent has tie-breaking authority on brand decisions
5. The analytics agent has tie-breaking authority on measurement decisions

This hierarchy is explicit — agents know the rules before the conflict happens. It's not a power struggle. It's governance.

4. State Management

Multi-agent workflows have state: where are we in the campaign launch? What's been completed? What's blocked? Who's waiting on whom?

The kernel maintains a shared state object for each workflow:

Campaign: Spring Collection 2026
├── Copy: ✅ Complete (Brigid, v2, accepted)
├── Ad Creative: 🔄 In Progress (Saoirse, waiting on final images)
├── Email Sequence: ✅ Complete (Niamh, 6 emails scheduled)
├── Tracking: ✅ Complete (Fionn, pixel + CAPI configured)
└── Creative Review: ⏳ Blocked (Oisín, waiting on ad creative)

Every agent can read the state. Only the kernel can update it. This prevents race conditions where two agents think they're responsible for the same task.

Project Management as Orchestration

Agentic orchestration isn't just about creative campaigns. It extends to:

Project Management: Breaking large initiatives into phases, assigning phases to agents, tracking progress, managing dependencies. The same kernel that routes campaign tasks routes development tasks.

Team Management: Monitoring agent performance across tasks, identifying agents that are overloaded or underutilized, recommending autonomy tier adjustments based on performance data.

Community Management: Coordinating responses to customer inquiries across channels — ensuring that the email agent and the social media agent give consistent answers, tone-matched to the brand voice.

The Event-Driven Architecture

AriaOS uses an event-driven architecture internally. Instead of agents polling for work, the kernel emits events:

• task.created — a new task needs routing
• task.completed — an agent finished its work
• context.updated — new data available that affects ongoing work
• conflict.detected — two agents have contradictory outputs
• escalation.required — something needs human attention

Agents subscribe to events relevant to their domain. Saoirse subscribes to task.created events tagged with "media-buying" and context.updated events tagged with "campaign-performance." She ignores email sequence events — those aren't her domain.

This architecture scales naturally. Adding a new agent to the team is subscribing it to relevant events and registering it with the kernel's routing table. No rewiring of existing agents required.

Infrastructure Choices

Orchestrating agents requires infrastructure decisions that have real consequences:

Communication Layer: We evaluated Notion (flexible, visual, but slow API), Supabase (real-time, SQL-queryable, excellent for structured state), and Jira (enterprise-grade, but overkill for agent teams). Supabase won for agent orchestration — real-time subscriptions for event-driven architecture, PostgreSQL for structured state, and Row Level Security for agent isolation.

State Persistence: Agent state needs to survive session restarts. Every state transition is logged to the database with timestamp, agent ID, and the state change. This creates a complete audit trail — vital for debugging and for the feedback loops in Step 12.

Context Windows: Multi-agent conversations consume more context than single-agent tasks. The orchestration layer manages context budgets per agent to prevent the "context overflow" problem where too many agents loading too much BIOS data exceeds model limits.

The Human Layer

Orchestration doesn't eliminate humans. It elevates them.

In a traditional workflow, the human does the work. In a single-agent workflow, the human supervises the work. In an orchestrated multi-agent workflow, the human provides strategic direction and exception handling.

My role in a Celtic Knot campaign launch:

• Set the strategic objective ("Launch Spring Collection, target 3x ROAS, heritage positioning")
• Review the creative director's brand approval
• Handle escalated decisions (new audience segment? increased budget?)
• Evaluate performance after launch

Everything between those touchpoints — copy production, campaign setup, email scheduling, tracking configuration — is handled by the orchestrated agent team. The human operates at the strategic layer. The agents operate at the execution layer.

That's not automation. That's organizational design — the same way a CEO doesn't write every email but ensures the organization produces the right emails.