Building Multi-Agent Orchestration Systems: From Single Agents to Coordinated Teams

Ai AgentsSettings

The paradigm has shifted. Nobody wants one agent anymore. The dominant mental model is now one coordinator agent managing teams of sub-agents (from agent orchestration coordination). Andrej Karpathy put it plainly: the highest-leverage skill in this new era is ascending layers of abstraction -- setting up long-running orchestrator agents with tools, memory, and instructions that manage multiple parallel coding instances for you (from karpathy coding agents paradigm shift). A weekend project that would have taken days three months ago can now be fully delegated to an agent that completes it autonomously in 30 minutes (from karpathy coding agents paradigm shift).

But coordination, not intelligence, is the bottleneck. Agent swarms fail from coordination failures -- task assignment, deduplication, handoff, and human-in-the-loop monitoring are the unsolved problems (from agent orchestration coordination). This guide is about solving those problems: how to design the orchestration layer, scope sub-agents, manage costs, wire up tools, and build the memory systems that make agent teams compound over time.

The Orchestrator Pattern: One Agent to Rule Them All

Why a Single Coordinator Beats a Swarm

The instinct is to throw many agents at a problem. That instinct is wrong for most use cases. The winning architecture is a single orchestrator agent that understands the full problem space, decomposes it into sub-tasks, and dispatches those tasks to specialized sub-agents with scoped tool access (from jimprosser chief of staff claude).

Jim Prosser, a non-programmer communications consultant, built a comprehensive chief-of-staff system using this pattern. One orchestrator runs a "Morning Sweep" that classifies tasks into four categories -- green (AI handles fully), yellow (AI preps 80%, human reviews), red (needs human brain), gray (not actionable today) -- and then dispatches to six specialized sub-agents running in parallel: one drafts emails, another updates client files, a third schedules meetings, and so on (from jimprosser chief of staff claude). The architecture matters more than the code: each component must know the others exist, with the email scanner producing metadata the morning sweep needs, the sweep assembling context packages sub-agents need, and the time-blocker reading all upstream output (from jimprosser chief of staff claude).

This is not a theoretical framework. The system runs on $5-10/month and replaces $400-1,000/month of virtual assistant work (from jimprosser chief of staff claude).

The Discord-as-OS Pattern

One concrete orchestration architecture that has emerged is the Discord-as-OS pattern: a coordinator spawns agents into structured channels, agents work in parallel and spawn sub-agents ("interns") for subtasks, then terminate them when done. Everyone sees progress in real time through the channel structure (from agent orchestration coordination). The insight here is that existing infrastructure like Discord -- which already solves coordination, visibility, and real-time communication -- may be a better substrate for agent systems than purpose-built platforms.

The Business Metaphor for Agent Organization

Paperclip, an open-source orchestration layer, takes this further by treating traditional business structures as agent configurations: org charts, goal alignment, task ownership, and budgets become primitives for multi-agent coordination (from paperclip autonomous business orchestration). The abstraction for agent companies mirrors human organizational design -- and that is not an accident. The coordination patterns that work for humans (hierarchies, clear ownership, explicit handoffs) work for agents too.

One practitioner structures their .claude folder with 35 agent markdown files organized into 7 departments: engineering (frontend developer, backend architect, mobile app builder, AI engineer, devops automator, rapid prototyper), product, marketing, design, project management, operations, and testing. Each agent is a standalone markdown file with instructions, personality, and scope (from one person startup claude agents). That is a one-person startup with 35 AI employees, all working 24/7.

What the Orchestrator Actually Does

The orchestrator's job is threefold:

  1. Decomposition -- Break the problem into sub-tasks that can run independently. Karpathy's key insight: the skill is decomposing work into agent-handoff-friendly chunks and helping around the edges (from karpathy coding agents paradigm shift).

  2. Dispatch -- Assign each sub-task to the right sub-agent with the right tools and the right context package. Subagents running in parallel with scoped tool access is the core capability that enables complex automation (from jimprosser chief of staff claude).

  3. Assembly -- Collect outputs from all sub-agents, resolve conflicts, and produce a coherent final result. Layered automation compounds: each piece assumes the others exist, and 36 hours of work compounds on itself (from jimprosser chief of staff claude).

Sub-Agent Design: Scoping, Specialization, and Tool Access

The Harness Pattern

Rather than configuring one general-purpose agent, build role-specific configurations tuned for different professional workflows. These "harnesses" -- designer, marketer, sales, researcher -- compound in value as more skills are added to a single harness (from claude code designer harnesses). The shift from generalist to specialist mirrors the broader AI agent trend: vertical specialization outperforms horizontal generalization for domain-specific tasks (from claude code designer harnesses).

The Six Extension Mechanisms

Claude Code provides six distinct extension mechanisms, each solving a different problem in the orchestration stack (from claude code extensions crash course):

The distinction matters for orchestration design. Skills teach agents what to know. MCPs give agents what to use. Subagents give agents who to delegate to. Hooks give agents what to enforce. Getting the right capability in the right mechanism is the difference between a clean system and a tangled one.

Scoping Sub-Agent Access

The most important design decision for sub-agents is tool scoping. Each sub-agent should have restricted tools and access, preventing one agent from touching things outside its lane (from jimprosser chief of staff claude). The .claude/agents/ directory is where you define this: each agent markdown file specifies a tools field that restricts what it can do, and a model field that lets you use a cheaper, faster model for focused tasks (from claude folder anatomy).

Practical example from the outbound sales system: Claude Code runs 11 APIs and 72 automation scripts. Instead of building rigid workflows, the agent gets tool access and figures out the execution path based on context and signals stored in Skills files (from claude code outbound sales agents). The key architecture pattern is storing domain expertise in Skills files rather than hardcoding workflows -- the agent reads positioning frameworks and copywriting guides to adapt dynamically (from claude code outbound sales agents).

When to Create a Sub-Agent vs. Use the Main Agent

Use sub-agents when:

Keep in the main agent when:

The Always-On Architecture: Background Agents and Scheduling

Turning the OS Into an Agent Orchestrator

The most powerful orchestration systems are not interactive. They run in the background, producing outputs before you wake up. Darrin Henein built a small staff of always-on agents running on macOS launchd that produce a tight, organized daily brief by 9am every day without manual triggering (from always on agents launchd obsidian). Every Friday, the system initiates a coaching conversation that reviews meeting transcripts, task progress, and goal alignment -- agents as accountability partners, not just task executors (from always on agents launchd obsidian).

The scheduling options for always-on agents:

The Pipeline Pattern

A practical always-on agent pattern chains multiple APIs into a single pipeline. Mike Fishbein's meeting prep tool runs at 7am daily (from meeting prep tool claude code):

Railway cron trigger
  -> Unipile calendar API (pulls Google Calendar events)
  -> Exa + Perplexity research (LinkedIn/company for each attendee, in parallel)
  -> Claude formatting (clean plaintext dossier per meeting)
  -> Resend email delivery (one email per meeting, title + time in subject)

The key performance pattern: run research queries in parallel per attendee (LinkedIn + company simultaneously) to meet a daily deadline. The dossier arrives in your inbox before your first meeting. No new tool to check -- delivery through familiar channels reduces adoption friction (from meeting prep tool claude code).

The AI-Native Agency OS

At the organizational level, an "AI-native agency OS" pattern is emerging where agents continuously scan client communication channels, auto-classify incoming work, assign it to team members, and suggest next steps in real time (from ai native agency os). The value proposition shifts the team from triaging and organizing work to pure execution -- the AI handles intake, classification, routing, and prioritization (from ai native agency os).

A CPO at Pendo runs a single Claude Code command that plans his entire workday (from claude code daily workflow vibePM). The mental model is not "grind during gaps" but "design your day differently because the work runs without you."

Cost Optimization: Hierarchical Model Routing

The 80/15/5 Rule

This is the single most important cost insight for multi-agent systems: 80% of agent tasks are "janitorial" -- file reads, status checks, formatting output. They do not require frontier model intelligence (from hierarchical model routing cost). The fix is hierarchical routing based on task complexity:

Task Type Percentage Model Cost/M tokens
Routine (file reads, status checks, formatting) 80% DeepSeek $0.14/M
Moderate (summarization, simple analysis) 15% Sonnet $3/M
Hard (complex reasoning, architecture) 5% Opus $15/M

Pure Opus costs $225/month. With hierarchical routing, the same workload drops to $19/month -- a 10x cost reduction (from hierarchical model routing cost). Even power users only need frontier reasoning for approximately 5% of their agent interactions (from hierarchical model routing cost).

Automated Smart Routing

ClawRouter operationalizes this with automated scoring: each request gets scored across 14 dimensions (reasoning markers, code presence, complexity, token count) in under 1ms and routes to the cheapest capable model. Blended cost drops from $75/M tokens to $3.17/M tokens (from clawrouter llm smart routing). The routing tiers in practice:

All routing runs 100% locally with zero external API calls for the routing decision itself, covering 30+ models across OpenAI, Anthropic, Google, DeepSeek, xAI, and Moonshot (from clawrouter llm smart routing).

Cost Architecture for Sub-Agents

The practical implication for orchestration: define your sub-agents with explicit model fields. Read-only exploration tasks get Haiku. Research and summarization get Sonnet. Architecture decisions and complex reasoning get Opus. The .claude/agents/ directory supports this natively -- each agent markdown file has a model field (from claude folder anatomy).

The winning agent orchestration solution will not come from a single AI lab -- it will be a mix of closed and open source models combined with deterministic orchestration logic (from agent orchestration coordination). Your orchestrator needs to be model-agnostic, routing to the cheapest capable model per task.

MCP Tool Integration: The Agent's Hands

MCP as the Standard Integration Protocol

MCP (Model Context Protocol) is becoming the standard way tool vendors integrate with AI agents. Linear now includes product management capabilities beyond issue tracking in its MCP server (from linear mcp product management). Anthropic open-sourced 11 domain-specific plugins spanning sales, finance, legal, data, marketing, and support (from anthropic open source plugins). The pattern is clear: every major tool will ship an MCP integration.

For orchestration systems, MCPs are the hands. They give agents the ability to read from and write to external systems. The meeting prep pipeline described above chains five different MCPs: calendar API, search APIs, LLM formatting, and email delivery (from meeting prep tool claude code). The Linear MCP closes the loop between planning and execution -- agents can directly read and write project management state (from linear mcp product management).

The Agent Economy Infrastructure

A map of the agent-economy primitives being built (from an economy of ai coworkers):

Stitch these together and you get a digital coworker with full operational capability (from an economy of ai coworkers). The orchestrator's job is to wire the right primitives to the right sub-agents for each task.

Agent Discovery

As the ecosystem grows, finding the right agent or tool for a task becomes its own problem. Matrix is a search engine trained on 100,000+ crawled agents, skills, and tools that matches capabilities to tasks -- a discovery layer for the agent ecosystem that improves through a gossiping network (from matrix agent search engine). Similarly, the npx skills add pattern for agent capabilities mirrors package management for code, creating a composable skill ecosystem where agents gain abilities through one-line installs (from agent browser electron skill).

Agent Observability: Monitoring Multi-Agent Systems

The DevOps Parallel

Agent orchestration systems need the same operational infrastructure as traditional software: observability dashboards, approval gates, cron scheduling, and cost optimization. The agent operational maturity curve mirrors DevOps (from Ai Agents).

OpenClaw Studio provides open-source, self-hosted agent observability with real-time dashboards, live chat with agents, approval gates for dangerous actions, and cron-based job scheduling -- enterprise-grade agent monitoring without the $500/month SaaS price tag (from openclaw studio agent dashboard). WebSocket streaming for real-time agent visibility signals that agents are increasingly long-running processes needing live dashboards similar to DevOps monitoring (from openclaw studio agent dashboard).

Approval Gates and Human-in-the-Loop

Approval gates -- human-in-the-loop for dangerous actions -- are becoming standard in agent management (from openclaw studio agent dashboard). The design principle from the chief-of-staff system is clear: default to "prep" (80% ready for human review) over "dispatch" (fully handled) when uncertain (from jimprosser chief of staff claude). The system never sends emails autonomously -- only drafts. It never makes pricing or strategic decisions (from jimprosser chief of staff claude).

For orchestration specifically, approval gates should sit at the boundary between agent output and external side effects. Internal agent-to-agent communication does not need approval. Writing to an external system (sending an email, updating a CRM, publishing content) does.

Hooks for Deterministic Guardrails

Hooks add determinism to non-deterministic systems. A stop hook with afplay /System/Library/Sounds/Blow.aiff in settings.json is essential when running 4-6 parallel sessions -- you need to know which one just finished (from every claude code hack mvanhorn). Game sounds from Starcraft, Warcraft, or Mario for task completion and permission notifications solve a real UX problem in autonomous multi-agent workflows (from claude hooks sound alerts).

Beyond notifications, hooks enforce consistency: run tests before committing, block dangerous commands, run formatters and linters automatically (from claude code extensions crash course). In a multi-agent system, hooks are your deterministic safety net against stochastic agent behavior.

Agent Memory: The Compounding Advantage

The Three Memory Patterns

Agent memory is not one thing. There are three distinct patterns, and orchestration systems need all of them:

1. Session History (lossy) -- What happened in this conversation. Useful but lossy by nature -- context windows have limits and older context drops off. This is the default and the weakest form.

2. Plans and Todos (static) -- Structured lists of what needs to happen. Static by nature -- they describe intended state, not learned behavior. CLAUDE.md instructions, task lists, and project plans fall here.

3. The Scratchpad / Napkin (live) -- A distinct form of context the agent writes to as it thinks. Not session history, not plans, but a live working document that captures mistakes, corrections, and what worked (from agent scratchpad napkin pattern). This is the pattern that enables compounding improvement.

Agents that log their own mistakes and corrections across sessions exhibit compounding improvement -- by session five, the tool behaves fundamentally differently (from agent scratchpad napkin pattern). The scratchpad pattern is a form of baby continual learning: a markdown file where the agent records errors and lessons becomes a lightweight memory system that bridges stateless sessions and true learning.

Declarative Memory Through CLAUDE.md

The simplest memory system is a one-line CLAUDE.md instruction: "When you complete work, log it to memory/weekly-recaps/current-week.md" (from weekly recap agent memory). Every task completion auto-updates the recap file. By Friday you have a full week log without writing a single thing yourself. Two-minute setup, permanent value (from weekly recap agent memory).

This demonstrates the power of declarative agent configuration: instead of building a feature, you describe a desired behavior in CLAUDE.md and the agent incorporates it into its workflow automatically (from weekly recap agent memory).

Curated Memory vs. Raw Logs

Effective AI memory should be curated and distilled -- decisions made, lessons learned, opinions expressed -- not a raw conversation log. The AI reads MEMORY.md every session and updates it when something worth remembering happens (from shpigford hyper personalization ai). After six weeks of accumulated personal knowledge, AI interactions shift from transactional to collaborative -- it stops asking clarifying questions because the answers are already in files it read seconds ago (from shpigford hyper personalization ai).

The "daily drip" pattern extends this: a cron job asks one thoughtful personal question per day, processes the answer, and files it to the right place. This adds more useful context after six weeks than the initial onboarding interview (from shpigford hyper personalization ai). For orchestration systems, the equivalent is having each sub-agent write a summary of what it learned back to a shared knowledge store after each task.

Self-Improving Skill Systems

The frontier of agent memory is skills that improve themselves. Siqi Chen built a Claude Code skill that observes usage patterns and automatically creates new skills -- meta-programming where the agent's capability set grows through use rather than manual configuration (from self learning claude code skills). Instead of static skill libraries, the agent's repertoire evolves based on actual workflows (from self learning claude code skills).

For orchestration systems, this means the orchestrator should track which sub-agent configurations work best for which task types and adjust routing over time. The system should get better at decomposition, dispatch, and assembly with every run.

Context Architecture: The Foundation of Orchestration

System Engineering Beats Prompt Engineering

The deepest insight from practitioners running hundreds of agent sessions: investing approximately two hours in context architecture means subsequent prompts can be as short as 10 words and still produce high-quality output (from claude cowork context architecture checklist). System engineering beats prompt engineering every time. Build the structure once, reap the benefits forever.

The minimum viable context setup is three markdown files (from claude cowork context architecture checklist):

Tiered Context Loading

A three-tier _MANIFEST.md in each project folder gives Claude a prioritized loading order (from claude cowork context architecture checklist):

Global instructions should direct Claude to read the manifest first, load only Tier 1 files, and ask clarifying questions before starting (from claude cowork context architecture checklist). This prevents context overload -- the most expensive failure mode in multi-agent systems.

Keep CLAUDE.md Under 200 Lines

Longer files eat context and instruction adherence drops (from claude folder anatomy). Use .claude/rules/ with YAML frontmatter path fields to scope rules to specific directories rather than bloating the main file (from claude folder anatomy). Confusing or conflicting instructions in CLAUDE.md files are the most common cause of unexpected behavior at high effort, per the Claude Code team themselves (from claude code effort levels).

Progressive Disclosure in Skill Files

Monolithic skill files are a performance disaster. Progressive disclosure means restructuring a single instruction file into a slim main file (table of contents) plus separate reference files loaded on demand -- reducing context from 1,625 lines to 183, an 89% reduction with no loss of functionality (from progressive disclosure claude skills). The instruction file for a skill should function like a table of contents: rules and decision logic up front, reference material (examples, templates, edge cases) in separate lazy-loaded files (from progressive disclosure claude skills).

Skills as State Machines

Power users build skills as complex state machines. Brad Feld's /start command is a 1,400-line markdown file with 15 steps. Mapping data dependencies between steps revealed 12-22 seconds of removable overhead from defensive checks that had become redundant (from claude skill state machine optimization). Skills accumulate "defensive machinery" over time -- checks added during development that remain as performance drag, suggesting periodic dependency audits for complex skills (from claude skill state machine optimization).

The framing of a skill as a "state machine with data dependencies" -- each step as a node with explicit input/output contracts -- is the advanced mental model for systematic skill optimization (from claude skill state machine optimization). For orchestration, this means the orchestrator's dispatch logic should be treated as a state machine too: explicit states, clear transitions, and auditable data dependencies.

Distributed Agent Swarms: Scaling Beyond a Single Machine

Autoswarms and Evolutionary Search

Hyperspace generalizes the orchestration pattern into distributed agent swarms. Users describe an optimization problem in plain English and the network spawns a swarm to solve it with zero code (from hyperspace agi autoswarms). The evolutionary loop: an LLM generates sandboxed experiment code, validates locally, publishes to a P2P network, peers opt in, and the best strategies propagate via gossip inside WASM sandboxes (from hyperspace agi autoswarms).

The results at scale: 237 agents with zero human intervention ran 14,832 experiments across 5 domains. ML agents drove validation loss down 75% through 728 experiments. Search agents evolved 21 scoring strategies pushing NDCG from 0 to 0.40. Finance agents converged on risk-parity sizing achieving Sharpe 1.32 with 5.5% max drawdown (from hyperspace agi autoswarms).

Cross-Domain Compound Intelligence

Research DAGs create cross-domain knowledge graphs where discoveries in one domain automatically generate hypotheses for others. A finance agent discovering that factor pruning improves Sharpe automatically generates a hypothesis for search agents that pruning low-signal ranking features might improve NDCG (from hyperspace agi autoswarms). Research DAG depth chains reach 8+ levels with hundreds of nodes, and an AutoThinker loop reads across all domains to synthesize cross-domain insights that no one explicitly programmed.

A "playbook curator" distills why winning mutations work into reusable patterns, so new agents joining a swarm bootstrap from accumulated wisdom rather than starting cold (from hyperspace agi autoswarms). This solves the cold-start problem in distributed evolutionary search and mirrors the scratchpad/napkin pattern at the swarm level.

When to Use Swarms vs. Orchestration

Use a single orchestrator with sub-agents when:

Use distributed swarms when:

Specialized Agent Products: Vertical Orchestration

Finance

Dexter, an open-source AI agent that reached 10K GitHub stars, combines OpenClaw and Claude Code to automate financial research: stock screening, financial breakdown, and thesis generation (from dexter finance ai agent). The finance vertical is well-suited for agentic automation because of structured data, clear evaluation criteria, and repeatable research workflows (from dexter finance ai agent).

Sales

Claude Code is being used as a full outbound sales platform with 11 APIs and 72 automation scripts -- campaign strategy, list building, and outreach that replaces traditional SDR teams (from claude code outbound sales agents). The next step is migrating from interactive Claude Code to the Claude Agent SDK for headless production deployment -- a "Claude Code to Agent SDK" pipeline is emerging (from claude code outbound sales agents).

Marketing

Okara's "AI CMO" deploys a team of marketing agents from just a website URL, representing the trend of packaging multi-agent systems as role-specific products with near-zero onboarding friction (from okara ai cmo agent). The highest-value agent products encode specialist judgment, not generic capabilities (from Ai Agents).

The Pattern

Every specialized agent product follows the same architecture: an orchestrator that understands the domain, sub-agents tuned for specific tasks within that domain, MCPs connecting to domain-relevant tools, and memory systems that capture domain-specific patterns. The domain expertise lives in Skills files, not in code.

Agent UX: Making Orchestration Legible

Cognitive Debt

Agents can do more, but if their output is hard to parse, the productivity gain is eroded by comprehension overhead. The concept of "cognitive debt" from agent interactions captures this: the gap between what the agent produced and what the human can actually absorb and act on (from visual explainer agent skill). Orchestration systems must invest in output formatting as much as task execution.

Conversation-Native Rendering

Tool UI renders JSON tool outputs as inline, narrated, referenceable surfaces within chat messages -- solving the problem of agent results being dumped as raw text (from tool ui react framework). "Conversation-native" is emerging as a design constraint: UIs optimized for chat width, scroll behavior, and inline rendering rather than traditional dashboard layouts (from tool ui react framework).

Skills that control output format (not just task execution) represent a new category of agent customization -- shaping how the agent communicates, not just what it does (from visual explainer agent skill). For orchestration systems, this means the orchestrator should have opinions about how sub-agent results are presented to the human, not just about what tasks get done.

Physical Interfaces

A Stream Deck + Claude Code combination creates a one-button trigger for complex multi-agent orchestration (from jimprosser chief of staff claude). Physical interfaces reduce the friction between intention and execution -- pressing a button triggers the entire morning sweep rather than typing terminal commands.

The Human-AI Interaction Design Space

The "AI Interaction Atlas" is a pattern library specifically for human-AI interaction design, signaling that AI UX is maturing enough to warrant its own dedicated design system (from ai interaction atlas). Human-centred AI design is becoming a distinct discipline, with practitioners creating shared vocabularies and reusable patterns rather than reinventing interaction models per product (from ai interaction atlas).

The Environment Layer: Making It All Work

Bypass Permissions for Autonomous Operation

For orchestration systems that need to run without human confirmation at every step, the exact bypass permissions config in settings.json is: "defaultMode": "bypassPermissions" plus "skipDangerousModePermissionPrompt": true. Without the second flag, Claude asks for confirmation every session. Shift+Tab toggles bypass mode (from every claude code hack mvanhorn). Claude Code Desktop also supports --dangerously-skip-permissions for fully autonomous operation -- the deliberately scary flag name is a UX pattern that makes the footgun obvious (from claude code desktop skip permissions).

The Dev Environment for Multi-Agent Work

Zed autosave at 500ms creates a Google Docs-like collab experience with Claude: {"autosave": {"after_delay": {"milliseconds": 500}}}. Claude edits appear in Zed instantly, and your typing is visible to Claude within a second. Pair this with a Ghostty + Zed split-screen layout (from every claude code hack mvanhorn). When running multiple parallel sessions, the stop hook with audio notification is essential to know which session just finished.

Effort Levels and Instruction Quality

Claude Code changed its default effort level from high to medium. Effort is configurable via the /model selector (low/medium/high) and the setting is sticky across sessions (from claude code effort levels). For orchestration, run the orchestrator at high effort (it makes routing decisions) and sub-agents at medium or low effort (they execute scoped tasks). Confusing or conflicting CLAUDE.md instructions are the most common cause of degraded output at high effort (from claude code effort levels) -- keep orchestrator instructions clean and unambiguous.

Building Your First Orchestration System

Step 1: Start with a Single Always-On Agent

Do not build a multi-agent system from day one. Start with one scheduled task that produces a daily brief. Use launchd or Claude Code Scheduled Tasks. Have it pull from your calendar and inbox, format a summary, and write it to a file or send an email (from always on agents launchd obsidian).

Step 2: Add a Second Agent for a Specific Task

Meeting prep is the highest-value second agent. Wire up the 5-API pipeline: calendar -> research -> format -> deliver (from meeting prep tool claude code). This teaches you the mechanics of agent pipelines without orchestration complexity.

Step 3: Build the Orchestrator

Once you have 2-3 independent agents running reliably, build the orchestrator layer. This is the Morning Sweep: it reads outputs from overnight agents, classifies remaining tasks, and dispatches to specialized sub-agents (from jimprosser chief of staff claude).

Step 4: Add Memory

Start with the one-liner CLAUDE.md instruction for weekly recap logging (from weekly recap agent memory). Then add the scratchpad pattern for the orchestrator itself -- let it log what worked and what did not across runs (from agent scratchpad napkin pattern). After two weeks, review the scratchpad and distill it into CLAUDE.md rules.

Step 5: Optimize Costs

Audit your Anthropic bill. Look at the 80/15/5 distribution. Route sub-agents to cheaper models for routine tasks (from hierarchical model routing cost). The orchestrator stays on a frontier model; everything else gets the cheapest model that can handle the task.

Step 6: Add Approval Gates

Put human checkpoints at every point where an agent writes to an external system. No autonomous email sending, no autonomous publishing, no autonomous financial decisions (from jimprosser chief of staff claude). The system defaults to prep over dispatch.

Step 7: Compound

Each layer assumes the others exist. Layered automation compounds: the overnight scan improves morning triage, better triage enables sub-agent dispatch, reliable dispatch makes time-blocking viable (from jimprosser chief of staff claude). Run the system for a month before adding complexity. Let the memory systems accumulate. The system will tell you what it needs next.

The Landscape: Who Is Building What

Seven of the top 10 fastest-growing GitHub projects in a single week are agent-related, spanning skills frameworks, context databases, AI-native browsers, and design languages (from fastest growing github ai agents). The ecosystem is moving fast. Key infrastructure players:

The convergence is clear: skill architectures are converging across different agent platforms toward common patterns, as evidenced by guides written "for any coding agent" rather than platform-specific (from building coding agent skills). Build on the patterns, not on any single platform.

Key Principles

  1. Coordination beats intelligence. The bottleneck is not model capability -- it is task decomposition, dispatch, handoff, and assembly.

  2. System engineering beats prompt engineering. Invest in context architecture, tiered loading, progressive disclosure, and CLAUDE.md discipline. Your prompts will be 10 words long and still work.

  3. 80% of tasks are janitorial. Route them to cheap models. Save frontier intelligence for the 5% that needs it.

  4. Default to prep over dispatch. The system never sends, publishes, or commits autonomously unless you have explicitly designed the approval gate for that action.

  5. Memory compounds. Scratchpads, weekly recaps, self-improving skills, and curated MEMORY.md files make the system better with every run. A system without memory is just an expensive script.

  6. Scope sub-agent access ruthlessly. Each sub-agent gets exactly the tools it needs and nothing more. The orchestrator is the only entity with a full view of the system.

  7. Start simple, add layers. One scheduled task, then two, then an orchestrator, then memory, then cost optimization. Each layer compounds with the others. Do not design the whole system on day one.

Sources Cited