Fable 5 Multi-Agent Build Orchestration
Run multi-step builds with Fable 5 sub-agents using contract-first briefs, file ownership, model routing, and verified merges.
Before & after
Same prompt, same agent — the only difference is the skill.
Multi-agent systems with Fable 5 can be powerful for complex tasks. You'd need to coordinate between different agents, manage shared memory or state, and route requests to the right agent based on what's needed. It's a bit complex because Fable agents are independent, so they need a way to communicate and share context. You could use a message queue, a shared database, or some kind of orchestration layer. What's the typical workflow you want to support? That would help determine the best architecture.
MULTI-AGENT FABLE 5 ORCHESTRATION ARCHITECTURE OVERVIEW Main orchestrator (Kai) routes tasks to 3 specialized sub-agents → Agent A: Research and analysis → Agent B: Writing and content creation → Agent C: Code generation and debugging Memory layer: Hermes (vector DB for context retention) Model routing: Claude Opus for orchestrator, Claude Sonnet for sub-agents (cost optimization) OPERATION FLOW 1. USER INPUT → ORCHESTRATOR Kai receives task: "Write a blog post about Python best practices" Kai analyzes intent and extracts metadata Decision: route to Agent B (writing) + Agent A (research) in parallel 2. ORCHESTRATOR → SUB-AGENTS Agent A spawned with instructions: "Research Python best practices, focus on async/await" Agent B spawned with instructions: "Write structured blog post outline from research" Both agents write outputs to shared memory (Hermes vector DB) 3. SUB-AGENTS COMPLETE Agent A output: research notes + 5 key sources Agent B output: blog post draft + SEO keywords Both outputs stored with embedding for future reference 4. ORCHESTRATOR REVIEWS Kai reads both outputs Checks quality gates (post > 2000 words, sources are recent) Routes to Agent C if code examples need verification Agent C: "Fix and test any Python code snippets" 5. FINAL OUTPUT Kai assembles final blog post from Agent B + verified code from Agent C + sources from Agent A Returns to user Logs conversation to memory for future context MEMORY PERSISTENCE (HERMES) Stored as vector embeddings with metadata tags: • previous research on Python topics • user's preferred writing style • common technical errors (code patterns to avoid) • successful blog structures When new task comes in, Hermes retrieves similar past work so agents don't reinvent wheels. MODEL SELECTION AND COST OPTIMIZATION Main orchestrator (Kai): Claude Opus (fast reasoning, complex routing) Research agent: Claude Sonnet (balanced cost/speed) Writing agent: Claude Sonnet (creative tasks, lower cost than Opus) Code agent: Claude Opus (safety-critical, debugging complexity) Estimated monthly cost: ~200 multi-agent tasks = 1200 (vs 2400 if all used Opus) AGENT CONFIGURATION (SKILL.MD EXCERPT) Specify for each agent: → Role (researcher, writer, coder) → Guardrails (what they can't do) → Output format (structured JSON for routing) → Error handling (when to escalate to orchestrator) → Memory access (read-only vs read-write for Hermes) DEBUGGING AND MONITORING Log each agent's decision and output Track latency (research should complete in 30 sec, writing in 60 sec) Alert if any agent fails 2x in a row Measure quality (user feedback on final output)
About this skill
Your sub-agents overwrite each other's files. Two of them build different payload shapes for the same API. Halfway through a long build the orchestrator forgets what it decided. This skill makes Fable 5 run builds the way a strong tech lead runs a team: it fixes the contracts first, gives each agent clear ownership, and trusts nothing until it has been checked.
What it does
- Decides whether a build should be parallelized at all, using file overlap and dependency order, not enthusiasm
- Writes shared contracts (API payloads, types, env var names, routes) before any sub-agent is spawned, so streams cannot drift apart
- Produces self-contained sub-agent briefs with owned files, forbidden files, a runnable done-check, and a capped return format
- Routes each stream to a deep or fast model tier based on how costly and how silent its failures would be
- Keeps a BUILD_LOG.md checkpoint, so a fresh session can resume a build without losing decisions
- Verifies each result against its done-check, resolves conflicts by contract, and merges in dependency order
What you get
An orchestration plan covering the split verdict, contracts, stream table, briefs, and merge order, followed by the coordination of the build itself. Quick questions get short, direct answers.
Best for
Developers using Fable 5 in Claude Code to run features or apps that span frontend, backend, data, and integration work, and who keep losing time to agent collisions and context loss.
SKILL.md preview
---
name: fable-5-multi-agent-build-orchestration
description: Orchestrates multi-step software builds with Fable 5 as the lead agent directing sub-agents. Writes shared contracts first, then self-contained briefs with file ownership and runnable done-checks, then routes model tiers, keeps a resumable build log, and verifies each result before merging. Use when the user says "coordinate sub-agents to build X", "split this build across agents", "my sub-agents keep overwriting each other's files", "Fable keeps losing context halfway through the build", "the agents built mismatched APIs", "set up parallel agents for this feature", "which model should each sub-agent use".
---
… (sign up to view the full skill)More ai & agents skills
View all AI & Agents skills →New Skill Scaffolder
Create a new Claude Code skill correctly: right mechanism, valid name and folder, a triggering description, and a smoke test.
Skill Library Lint and Overlap Report
Lint every skill in a repo at once: frontmatter, name-folder match, weak descriptions, overlapping triggers, broken refs, plus a CI script.
Self-Verifying Agent Loop: Plan, Check, Retry, Close
Turns a goal into a task plan with machine-run checks, executes with retry caps, escalates, and refuses to close until verified.
Skill Test Runner (Trigger and A/B)
Test a skill in fresh sessions: ready-to-run prompts, commands, and rubric for trigger recall, false triggers, and blind A/B.