Share
One catalog of MCP servers, tools, and skills, merged into each harness after a dry-run diff.
[ ESCOFFIER LABS · BRIGADE ]
Your agents run loops. Brigade keeps the receipts.
Local control plane for multi-agent coding. Every check your agents run leaves a file receipt with the real exit code, a built-in code graph records what the change touched, and one reviewed home holds the MCP, tools, and memory they share. No daemon, no lock-in.
In plain terms: an agent that says "tests pass" is making a claim. Brigade turns the claim into a record, keeps one reviewed home for the config and memory your agents share, and lets a real exit code, not the model's say-so, decide what they keep.
Seven verbs to learn: setup · init · add · sync · brief · verify · run. Everything else stays hidden until you opt in.
Just Claude CodeHandoff inbox, memory cards, your MCP servers synced, receipts on verify. Two or more CLIsOne catalog merged into every native config. The strongest reason Brigade exists. Always-on agentWorkspace-depth install. OpenClaw or Hermes owns the canonical memory. Kicking the tiresTemplate files or a read-only inventory. Nothing you did not ask for.
[ 01 · THE HUB ]
Four jobs, two built-in engines, then optional stations
In plain terms: Brigade is the control plane. Code and Evidence are built in, formerly the GraphTrail and MiseLedger sidecars. Agent Pantry and the rest are optional stations you add when you need them. Core works alone; stations plug into the same loop.
Remember
Handoffs between sessions and agents, linted and filed, without bootstrap bloat.
Prove
File receipts for verify and run: command, real exit code, what changed.
Improve
Promote skills only on those exit codes. Roll regressions back. No model self-score.
Code Intelligence
Local code graph (callers, callees, impact). When a graph is present, brigade run prepends a capped context pack so workers start from structure instead of grepping blind.
Evidence Memory
Local evidence ledger of sessions and notes. Export a bundle into work context; the next run gets a measured evidence brief, not a hunch.
Agent Pantry
brigade add pantry · plugs into Share Encrypted browser-session and secret sync across machines so agents inherit working logins instead of a pile of expired cookies.
Content Guard
brigade guard / scrub · plugs into Share / Remember Publish gate for secrets and private detail, embedded in brigade-cli.
Skills / Skillet
Portable skills across harnesses; reconcile promotes or rolls them back from real exits.
Token Glace
brigade add tokens · plugs into Prove Compact noisy tool output before it burns agent context. Deterministic reducers, raw one flag away.
brigade status and brigade doctor health-check whatever is installed. Skip optional stations and the hub still runs. Full station cards live lower on the page.
[ 02 · THE PROBLEM ]
Why this exists
Brigade came out of running several coding agents against one shared memory, and watching that setup fail quietly, twice.
In plain terms: every coding agent has its own brain, and nothing checks what goes into it or whether it ever gets read.
The index that bloated
A background job kept appending to the memory index until it blew past the session load budget. Every new session silently truncated it. Nothing errored. It took weeks to notice.
The notes nobody read
195 handoff notes from agents sat unread across 35 repos, because the ingest script had a hardcoded allowlist. The agents kept writing. Nothing was reading.
Silence is the failure mode
Every part of Brigade that lints, warns, or writes a receipt exists because something once failed in silence.
If you run more than one agent CLI the problem compounds: Claude Code, Codex, Cursor and friends each keep their own MCP config, their own skills, their own memory. You fix a server in one and the others drift.
Brigade's answer: every piece of work runs one circuit.
intenttask + acceptance criteria
contextprior evidence + code impact
bounded runreplaceable workers
verifyreal exit code
receiptledger · memory · rank
Work enters as intent and leaves as evidence. The next run starts from verified history, not chat scrollback.
[ 03 · THE BIG PICTURE ]
One reviewed source, synced everywhere
In plain terms: you keep one catalog in your repo. Brigade copies it into whatever config format each tool expects, and agent notes flow back the other way.
- Dry-run by default.
brigade mcp syncshows the plan;--writeapplies it. - Merges by server key. Servers you added by hand in a tool are never overwritten.
- Secrets stay
${VAR}references. Keys are never inlined into config files.
[ 04 · THE MEMORY ENGINE ]
Memory that survives the session
At its core Brigade is a memory engine: agents leave notes, the notes get linted and routed, and durable knowledge lands where every future session loads it.
In plain terms: your agents already learn things every session. Brigade is how those lessons stop dying when the context window closes.
memory/cards/
Knowledge cards hold the detail. One fact per markdown file, with frontmatter, greppable and diffable like any other code.
MEMORY.md
A slim index, one line per card, loads every session. It stays small so it can never blow the context budget again.
an agent finishes work and drops a handoff note in its own inbox.claude/memory-handoffs/ · .codex/memory-handoffs/ · 19 harnesses
brigade lints and classifies the note
safe, targeted notes file themselves into durable memory
ambiguous or risky notes wait for human review
the next session starts smarter, with a paper trail
Brigade never edits canonical memory itself. The owner does the writing, you or your always-on agent.
Cards are also served read-only over MCP (search_cards, get_card), so any harness can recall them mid-task.
[ 05 · THE TRUST LOOP ]
The model never grades its own work
In plain terms: an agent saying "done, all tests pass" is an opinion. Brigade records the actual exit code and scores the workflow that produced it.
What is pending, what is stuck, and whether the loop itself is healthy.
Runs your real test command and writes a receipt with the real exit code.
Scores that result, pass or fail, against the skill or card that guided the work.
The ratchet. Promotes workflows that keep passing, rolls back ones that regress. Dry-run by default, reversible always.
Ranking uses a Wilson lower bound: two lucky passes never outrank twenty vetted runs. The whole ledger is JSON and markdown under memory/outcome/, tracked in git.
[ 06 · THE SCORING SYSTEM ]
How self-learning gets scored
Brigade's learning loop is called the ratchet. It promotes a skill or memory card only when signals the model cannot author say it helped, and rolls it back when a real signal measures a regression.
In plain terms: the loop never asks a model "did that go well?". It counts exit codes, and it needs more than one before it trusts anything.
SIGNAL WEIGHTS · ONLY SIGNALS THE MODEL CANNOT AUTHOR SCORE
| signal | weight | what it means |
|---|---|---|
| verify completed | +1 | your real test command exited 0 in a receipted run |
| verify failed or timed out | -1 | it did not |
| friction cleared | +1 | a logged recurring annoyance stopped recurring |
| friction recurred | -1 | it came back |
| learning cleared / recurred | +1 / -1 | same rule for logged lessons |
| worker exited cleanly | 0 | advisory only. A clean exit is not a passing test |
| manual replay comparison | 0 | advisory only. A human eyeball is not a receipt |
One receipt, one signal
Signals are keyed to the physical receipt file. Re-running or re-capturing the same receipt is deduplicated, so a single lucky run can never be farmed into an auto-promotion.
Ranked by Wilson lower bound
Artifacts are ranked by the lower bound of a 95 percent Wilson interval, not by raw pass rate. Zero trials scores 0.0, so unproven never outranks vetted. Two passes out of two scores 0.34. Eighteen out of twenty scores 0.70. The flashy newcomer loses to the boring veteran until it earns it.
Thresholds with hysteresis
Install a candidate after 2 distinct verified helps. Roll back after 1 measured regression. Promote further at 3. A 24 hour per-artifact cooldown stops flapping.
SINCE v0.22.0 · SCORES ARE FINGERPRINTED, CONTEXT-AWARE, AND FORGETFUL
Scores are fingerprinted to the exact revision
Every receipt stamps a content_fingerprint of the artifact that earned it. Edit a skill and it re-earns its score against the text that ships now: outcome rank and explain drop records fingerprinted to a stale revision while keeping the lifetime count visible. A card's fingerprint folds in the cards it [[links]], so editing one invalidates every card that reaches it.
Ranked for the harness you actually run
outcome rank --by-capability scores what worked under your current context. Each record carries a capability_fingerprint over your harness, model family, Python, and platform, and a thin cohort is pulled toward the pooled rate by deterministic shrinkage. A skill that only ever passed under a different model does not get to vouch for itself under yours.
Old credit fades on purpose
outcome rank --recency halves a signal's weight every 45 days, so a score earned under an environment you have since drifted away from stops carrying full weight. It is off by default and never rewrites the append-only log. The promotion ratchet itself never uses recency: fading changes what you read, not what auto-installs.
Every decision is explainable and reversible
brigade outcome reconcile is dry-run by default; --apply performs the install or rollback across your harnesses. brigade outcome explain prints the full signal trail: which run produced each signal, which threshold was crossed, and the reversible action taken. The whole ledger is plain JSON and markdown under memory/outcome/, tracked in git. No model ever grades its own work anywhere in this loop.
[ 07 · WHY NOT JUST DREAMING? ]
Reflection writes. The ratchet decides.
Most agent stacks now have some reflection loop: the model reviews its own transcripts in the background and writes what it learned into memory. Whether that lives in OpenClaw, Hermes, or a cron job you wrote, it shares one weakness: the writer grades its own homework.
In plain terms: dreaming is a great way to capture experience and a terrible way to decide what is true. Brigade keeps your reflection loop and takes away its power to promote junk.
SELF-GRADED REFLECTION VS THE RATCHET
| a reflection loop alone | with the ratchet in front | |
|---|---|---|
| who decides it worked | the model's opinion of itself | an exit code the model cannot author |
| a wrong lesson | compounds quietly, session after session | earns a -1 and gets rolled back |
| memory growth | unbounded appends | linted, routed, review-gated |
| where the state lives | often inside one vendor's store | markdown and JSON in your git |
| when it fails | silently | the receipt names the exact run |
This is a scar, not a theory
Brigade exists because a dreaming job once promoted raw session fragments straight into a memory index until it blew past the session load budget. Every session silently truncated for weeks. The ratchet is the mechanism that makes that class of failure impossible: nothing is promoted without a verified signal, and nothing that regresses stays promoted.
This is not a replacement pitch. Keep OpenClaw's dreaming, keep Hermes' loop, keep your own reflection cron. Brigade sits in front of the canonical memory they feed: handoffs get linted and routed, promotions need receipts, and everything your agents learn stays portable markdown in your repo instead of state trapped in one tool.
[ 08 · BRIGADE RUN ]
Several models, one task, one receipt
brigade run is the expediter: one plain-language task goes in, a deterministic router derives what the task needs and composes the stages into parallel waves, workers execute through the CLIs you already pay for, and the lead stitches the results together.
In plain terms: you type one sentence. Brigade reads the task, decides which stages it needs, runs the independent ones in parallel, and a strong model writes the code. You get a patch plus a paper trail.
THE ROUTER IS DETERMINISTIC ·
brigade route "<task>" SHOWS THE PLAN BEFORE A SINGLE MODEL IS CALLEDone plain-language taskrewrite the auth flow · add a migration · fix the panel
derive signalsauth surface · UI · migration · bug · docs · ship request
compose dependency-ordered parallel wavesindependent stages run together; while / until holds gate the rest
fill the roster, run the waves, synthesize one receipt
brigade route "<task>" prints the signals, stages, waves, and held stages before anything runs. --route-signal +auth-surface or ~ship-requested corrects the heuristic on one task, --wait queues behind an active run lock, --no-route opts out. The route lands in run.json with the signal that pulled each stage in.
Bounded on purpose
Two orchestrator calls plus the workers in the plan. No recursive delegation, no runaway loops, a per-repo run lock.
Your roster, your models
The roster is a TOML file: seats, each with a CLI and a pinned model. A working split: chef and coder on gpt-5.5, scout and reviewer on gpt-5.3-codex-spark. The cheap seats do recon and adversarial review, the strong seats write code.
[agents.scout] cli = "codex" model = "gpt-5.3-codex-spark" role = "Read-only recon. Never modifies files."
Worktree isolation
--worktree runs workers in a detached checkout and hands back changes.patch, so nothing touches your working tree until you apply it.
Any CLI with an adapter
claude · codex · grok · opencode · pi · kimi · cursor · antigravity · local ollama
ROADMAP · sharded scout swarms: fan a big inventory across many cheap spark workers, let a stronger model judge the evidence. Parked branch today, not a shipped command.
[ 09 · ALONGSIDE WHAT YOU RUN ]
It joins your setup. It does not replace it.
In plain terms: no new agent, no new model, no wrapper around your tools. Brigade is files plus a CLI. Your agents keep running exactly as they did yesterday.
Adopt before you change anything
brigade operator adopt plan inventories the setup you already have, homegrown scripts and all, and changes nothing. You see the plan before any file is written. Init and sync are dry-run by default everywhere.
Merges, never clobbers
MCP sync merges by server key into each tool's own native file. Servers you added by hand survive. Your existing CLAUDE.md and AGENTS.md are never overwritten; Brigade adds alongside them.
The owner stays the owner
Whoever writes your canonical memory today keeps writing it: you, an always-on OpenClaw workspace, or Hermes. Brigade never edits canonical memory itself. It lints what flows in, routes it, and keeps the receipts.
Leaving costs nothing
Delete the Brigade files and you are out. Synced configs are still valid native configs for each tool. Memory is still markdown in your git. There is no export step because there was never a proprietary store.
[ 10 · WHICH DEV ARE YOU? ]
It meets your setup where it is
In plain terms: you do not need the whole kitchen. Every lane below is the same engine, just more or less of it.
The default harness. You get a handoff inbox, durable memory cards with a slim index, your MCP servers synced into .mcp.json, and a skill that makes verification leave receipts.
pipx install brigade-cli brigade operator quickstart --target . --harnesses claude brigade work brief --target .
The strongest reason Brigade exists. One catalog merged into every native shape: .mcp.json, .codex/config.toml, .cursor/mcp.json, .vscode/mcp.json, opencode.json. Fix a server once. Memory is shared across harnesses instead of siloed per tool.
brigade mcp add github -- npx -y @modelcontextprotocol/server-github brigade mcp sync # dry run, shows the plan brigade mcp sync --write # applies it
Workspace-depth install. Your agent's workspace becomes the canonical memory owner, and handoffs from every other harness flow to it through the ingest loop.
brigade operator quickstart --target ~/agent-workspace \ --depth workspace --harnesses openclaw,hermes --owner openclaw
Template files only, or a read-only inventory of the homegrown setup you already have. Neither changes anything you did not ask for.
brigade init --harnesses none brigade operator adopt plan # inventories, changes nothing
19 harnesses have handoff inboxes today, including Aider, Goose, Copilot CLI, Qwen Code, Amp, and Grok.
[ 11 · ENGINES AND STATIONS, THE DETAIL ]
Two built-in engines, then every optional station
In plain terms: the early hub section is the map. This is the ledger: what brigade setup builds in, what each optional station adds, and the install command for each when you actually need the detail.
Code
built in, formerly GraphTrail ·brigade code sync|context|impact A local tree-sitter code graph in SQLite: symbols, imports, call edges for Python, TypeScript, Rust, and Go. When brigade run sees a graph in the repo it prepends a capped context pack to every worker prompt, so workers start knowing callers, callees, and impact instead of spending their first ten tool calls grepping. Any harness can query it over MCP too.
Evidence
built in, formerly MiseLedger ·brigade evidence search|crawl Local-first evidence ledger with receipts and source exporters. When someone asks how you know, you have the bundle, not a vibe.
guard
brigade guard · brigade scrub The content guard scanner is embedded in brigade-cli. brigade guard exposes scan, redact, Git, PR, and publish checks, while brigade scrub gives you the repo gate out of the box.
token-glace
brigade add tokens Tracks token spend across harnesses and compacts noisy output. You see which agent burned the budget and why, instead of guessing from invoices.
memory-doctor + bootstrap-doctor
brigade add memory Flags stale, contradictory, or oversized memory before it quietly rots. This is the check that catches an index growing past the session load budget before sessions start truncating.
agentpantry
brigade add pantry Encrypted browser-session and secret sync between your machines, so a second machine's agents inherit working logins instead of a pile of expired cookies.
code-search
brigade add search · separate from the built-in code graph Local semantic code search across your repos. Embeddings find the idea when you do not remember the words.
agent-notify
opt-in hooksPings you when long-running agent work actually finishes, so you stop babysitting terminals.
skillet
npx skills add escoffier-labs/skillet Reviewed, versioned skills installable into seven-plus harness formats. Write the workflow once, every agent on the machine runs the same playbook.
Every station reports its own health: brigade search|tokens|evidence|pantry status, brigade memory status|lint|compact, and brigade stations verify|discover. brigade status and brigade doctor roll it into one table, and nothing runs that you did not install.
Built-in spotlight · Evidence + Code
Evidence, the combined edition
Evidence, formerly MiseLedger, used to be three tools. StationTrail exported agent-session logs, SourceHarvest exported files and git history, and MiseLedger stored them. The current version absorbed both, and the old repos are archived. Built-in crawlers now read Codex, Claude Code, OpenClaw, OpenCode, Hermes, and Cursor session history, plus markdown, HTML, JSON, and git history, plus official ChatGPT and Claude conversation exports. External crawlers cover Discord, GitHub, Slack, Gmail, Notion, and Telegram. Everything normalizes into one adapter contract and lands in a single local SQLite ledger with full-text search, raw payloads preserved for audit, fully offline.
What that looks like mid-build
Three weeks into a project you hit a bug you know you solved before, somewhere: a Codex session, a Discord thread, a note. brigade evidence search "cookie rotation" returns the ranked evidence with source and date in one query instead of six app searches. Evidence bundles attach to a plan as quarantined context, marked untrusted, so pasted transcript text is treated as evidence and never as instructions.
Where Code plugs in
The code graph answers the structural half of the same question. It knows which symbols call the function you are editing, and its links command joins those symbols against the Evidence ledger by full-text search, so a function connects to the sessions and threads where it was actually figured out. The framing the tools are built around: embeddings find the idea, full-text finds the words, the graph finds the relationships, receipts explain the provenance.
And inside a brigade run
When a code graph exists in the repo, brigade run prepends its capped context pack to every worker prompt automatically. Evidence bundles ride in through brigade work import context. Workers start with the call paths and the paper trail instead of a cold grep, and everything they were shown is traceable to a source.
[ 12 · WHY, HOW, WHY NOT ]
The questions you are already asking
In plain terms: the honest answers, including the ones where the answer is "you might not need this."
For one repo and one tool, do exactly that. The problem starts at two tools: configs drift, nothing lints what agents append to memory, and nothing warns when a note is never read. Brigade is the difference between files you hope are right and files something checks.
Different layer. Services like mem0 are memory you build into an app you are shipping. Brigade wires the coding agents you already run: plain local files, a review gate, receipts, no API dependency. You can use both. Full comparison.
Because confident junk compounds. Self-assessment is the one signal a model can always produce, so the ratchet gives it zero weight. Promotion requires an exit code, and regression requires only one to trigger a rollback.
No. Brigade never calls a model on its own. The only time it talks to one is when you run brigade run, and then it goes through the CLIs and subscriptions you already have.
Not for single-harness work; native subagents are excellent there. brigade run is for the mixed fleet: pin a different vendor per seat, get structural review independence from a model that did not write the code, and a receipt for the whole run.
No daemon, no hosted service, no telemetry. Secrets are written as environment variable references, never inlined. The embedded guard scans what you choose to publish before it leaves.
Brigade de cuisine: the staff running the line, mise en place: everything prepped before service. The metaphor lives in names and help text. The commands you actually type are plain: init, add, sync, doctor, brief, verify, run.
Six verbs. Everything else is progressive disclosure: extra command groups stay hidden until you opt in, and brigade doctor tells you what needs attention instead of making you memorize a manual.
[ 13 · WHAT IT IS NOT ]
The 86 board
In plain terms: 86'd means off the menu. These stay off.
Everything Brigade writes is a plain file in your repo. You can grep it, diff it, and roll it back. A review gate sits in front of anything consequential. That pause is the point.