Engineering · April 2026 · Open source

The organizational layer for Claude Managed Agents.

Conclave brings roles, deliberation, and auditability to multi-agent systems built on Anthropic primitives. A thin, opinionated framework that treats organizational coordination — not a graph — as the first-class object.

Conclave contributors · reference implementation MIT licensed 27 tests · CI green · CodeQL

A bureau, not a graph.

Most multi-agent frameworks model tasks or graphs. Real organizations don't work that way. They work through roles that hold persistent accountability, deliberate together, and leave an audit trail. Conclave makes that the primitive.

— 01

Roles, not tasks.

Define your org in YAML. Each role has a persona, a reporting line, a toolset, and persistent memory. Non-engineers can read and amend it.

— 02

Token-aware routing.

A classifier decides per task: repetitive work runs a Haiku self-correction loop, novel work goes to Sonnet. Savings on production workloads run 60–80% versus frontier-only.

— 03

Decision Trail, always on.

Every inter-agent message lands in a JSONL trail with sender, recipient, reasoning, and cost. Render it as a Mermaid sequenceDiagram with conclave trail view — postmortem-ready in one command.

— 04

Live control plane.

A single-file dashboard ships with the framework — four MetricCards, four ChartCards, a live SSE activity stream, and a dual feed. Visually grounded in the Anthropic design system.

Define an organization. Give it a goal.

A Conclave is a small group of Claude-backed agents, each anchored to a role, working through a structured deliberation until a concrete output is produced. The configuration below is the entire specification.

examples/product_squad.yml
org:
  name: "Product Squad"
  deliberation: hierarchy
  backend: managed_agents   # anthropic | managed_agents

  agents:
    - role: CPO
      persona: "Strategic. Defines scope. Validates value."
      tools: [notion, slack]
      force_model: claude-sonnet-4-6

    - role: TechLead
      persona: "Tight specs. Two options, not one."
      reports_to: CPO
      tools: [github, linear]

    - role: QA_Engineer
      persona: "Adversarial. No approval without test plan."
      reports_to: TechLead
      tools: [github, browserbase]

 

Running it is one command. Add --dry-run to simulate the pipeline end-to-end — trail, cost accounting, deliberation — without spending a single token.

terminal
$ pip install conclave-agents
$ conclave init --template product-squad
$ conclave run "Spec the checkout API" --dry-run

◆ Conclave · Deliberation started
  [user]     → CPO
    Spec the checkout API
  [CPO]      → TechLead
    Please pick this up.
    ↳ delegating to TechLead
  [TechLead] → QA_Engineer
    Your turn. Flag blockers early.
    ↳ delegating to QA_Engineer
  ✓ Output from QA_Engineer

◆ Deliberation complete
  Trail →  .conclave/trail_20260419.jsonl

  haiku     865 in    359 out   $0.0021
  sonnet    988 in    328 out   $0.0079
  ─────────────────────────────────────
  TOTAL                         $0.0100
  BASELINE (all-Sonnet)         $0.0159
  SAVED    $0.0059  (36.9%)

Built on Anthropic primitives.

Conclave does not reinvent the agent. It wraps Managed Agents sessions in a coordination layer, binds tool access to MCP servers, and routes across the Claude model family. Every Anthropic release is a step forward, not a rewrite.

Input Conclave runtime Anthropic primitives conclave.yml org chart personas tools · backend Conclave runtime Task Router classifier · novelty · complexity decides model & executor per turn Conclave Bus routes messages between agents hierarchy · consensus · first-valid Decision Trail JSONL · provenance · replayable Cost Meter per-role · vs all-Sonnet baseline Backend abstraction anthropic_direct · managed_agents (beta) · dry_run Managed Agents sessions · persistent state beta 2026-04-01 MCP Model Context Protocol tools · connectors Claude model family Haiku · Sonnet · Opus

Figure 1 — YAML configuration is the only input. The runtime coordinates agents, logs every decision, and calls Anthropic primitives through a swappable backend.

A control plane, not a log tail.

A live dashboard ships with the framework — single file, dark surface, built on the tokens npx getdesign add claude produces. It gives you the state of the deliberating org in one screen: metric cards, 14-day charts, and a dual feed that reacts to the SSE stream off the Decision Trail.

launch it
$ conclave dashboard
◆ Conclave Dashboard → http://localhost:7777

The dashboard is powered by the same JSONL trail that conclave trail view renders as Mermaid. Pollers that target Anthropic agents typically refetch every few seconds — Conclave emits events on /api/events as soon as the trail file changes, so a new handoff appears in under 500 ms.

layout
  • Sidebar — org hierarchy tree + certification share progress.
  • 4 MetricCards — agents · deliberations today · spend · routing savings.
  • 4 ChartCards (14d) — run activity · handoffs by type · cost by role · model routing split.
  • Dual feed — live activity (SSE, with "just arrived" pulse) + recent outputs.
  • Incident banner slot for budget or policy alerts.

Warm dark palette (#141413 / #30302e), terracotta accent (#c96442) reserved for live indicators and CTAs, serif headlines (Fraunces as Anthropic Serif proxy). No cool grays — every neutral has a yellow-brown undertone, consistent with the Claude design system.

Each task is classified before it runs.

A persistent agent's history grows with every turn. We refuse to pay a Sonnet bill to format a table. The router runs a Haiku classifier on each task, then dispatches — Haiku loop for the routine, Sonnet for the novel, Opus only when the domain warrants it.

Incoming task from user or peer agent Classifier Haiku · ~100 tokens novelty · complexity is_repetitive · needs_fs low novelty · repetitive otherwise (default) force_model: opus Haiku correction loop execute → evaluate → correct · up to 4 iterations escalates to Sonnet on exhaustion Sonnet deliberation single call with full role history Opus (opt-in) high-stakes reasoning · legal, strategy, audit

Figure 2 — A task is classified on Haiku, then dispatched. Low-novelty work runs a Haiku self-correction loop; novel work goes to Sonnet; Opus is reserved for explicit, high-stakes domains.

A full exchange, inspectable end to end.

Every handoff is a message with explicit sender, recipient, type (delegation, handoff, escalation, output) and reasoning. The diagram below is a real deliberation rendered from the Decision Trail.

User CLIENT CPO STRATEGY · SONNET TechLead DELEGATION · HAIKU QA_Engineer EVALUATION · HAIKU Trail JSONL Spec the checkout API delegation · 09:01:12Z Scope: auth, idempotency, rollback. handoff · Sonnet Spec attached. Prioritize payment edge cases. handoff · Haiku loop ×2 3 blockers. payment-service v3 missing in staging. escalation → CPO · Haiku

Figure 3 — Four messages across three roles. Each line is one entry in the JSONL Decision Trail, timestamped, with the model that produced it.

Where it sits next to existing tools.

Multi-agent frameworks have proliferated. Most rebuild primitives Anthropic already ships. Conclave chooses the opposite: stay thin, lean on Managed Agents and MCP, and add the one thing nobody else does — the organizational layer.

  LangGraph CrewAI AutoGen Conclave
Agent primitive Graph node Task worker Chat participant Organizational role
Coordination Explicit DAG Linear pipeline Free-form chat Deliberation mode
Memory Checkpointer Per-task Per-conversation Persistent, per-role
Cost control Manual Manual Manual Router: Haiku / Sonnet
Audit Optional traces Logs Chat history Decision Trail, always on
Config surface Python graph Python + YAML Python YAML-first
An org isn't a DAG — it's a living system of accountabilities. — Conclave README · Philosophy

Forward-compatible by design.

Conclave's backend abstraction means switching from the stateless messages.create() path to native Managed Agents sessions is a one-line YAML change. When the beta goes GA, the migration is a no-op.

org:
  backend: managed_agents

Zero config. No API key for the dry-run.

Install, initialize from a template, simulate the full pipeline — then swap in an API key when you're ready for a real run.

install & run
$ pip install conclave-agents
$ conclave init --template product-squad
$ conclave run "Your goal" --dry-run
observe live
$ conclave dashboard
◆ Conclave Dashboard → http://localhost:7777
share a trail
$ conclave trail view --latest > trail.md
# Mermaid sequenceDiagram, renders on GitHub
benchmark — 20 canonical tasks
$ conclave benchmark

Category      Haiku    Sonnet   Conclave   Quality
──────────────────────────────────────────────────
repetitive    $0.008   $0.062   $0.009      97%
operational   $0.011   $0.081   $0.024      91%
technical     $0.014   $0.098   $0.071      96%
strategic     $0.009   $0.071   $0.065      98%
──────────────────────────────────────────────────
TOTAL         $0.042   $0.312   $0.091      94%

~70% saved versus all-Sonnet at 94% quality parity. Every task lives in the repo — reproduce with one command.

Star on GitHub Read ANTHROPIC.md Implementation roadmap