Case study — Consistorium at Corpus · August 25, 2026

How a Chat Model That Can’t See the Code Became Our Agentic Fleet’s Strategist

Corpus forms companies in all 50 states and compiles US law into a free public library. Day to day, its engineering runs on a fleet of coding agents — Claude Code, Codex, and friends — working in parallel worktrees, landing real code against real deadlines.

Somewhere in that operation we hit a wall that almost nobody talks about, because it isn’t a model-quality problem. It’s a visibility problem.

The strategist is blind

Our best strategic reasoning didn’t live in the coding harness. It lived in long-running conversations with a strong reasoning model — the one tracking goals, tradeoffs, sequencing, what “done” means for a feature. That model knew why we were building things.

It could not see what was actually in the repo.

The standard workaround is copy-paste: paste git log into chat, paste file excerpts, summarize where things stand. We did that for months. It has one fatal property: the context is stale by the time it lands. The strategist was reasoning over a snapshot of a codebase that three agents were actively changing. Sometimes confidently. In the wrong direction.

Meanwhile the coding agents held the repo but burned their metered allocation figuring out what to do — re-reading directory structures they’d seen yesterday, rediscovering decisions that had already been made, orienting instead of implementing.

Two smart models. Each missing exactly what the other has.

What the meter actually paid for

When we watched where agent time went, a lot of it wasn’t coding:

re-reading repo structure it saw yesterday
rediscovering decisions already made
deciding what to do instead of doing it

Roughly half of our per-feature burn was this orientation overhead. (Your mileage will differ — but if your usage windows die fast, watch what the agent is doing when it dies. It usually isn’t writing code.)

That’s not a prompt-engineering problem. Orientation needs current ground truth, and no chat session can hold that for you.

The fix: give the strategist read-only eyes

So we flipped the direction. Instead of dragging context into the chat, we gave the chat model a bounded, live window into the repos. That tool became Consistorium — a local MCP server we’ve now open-sourced (Apache-2.0, github.com/Renaissance-AI-Solutions/consistorium).

The daily loop at Corpus now looks like this:

The strategist asks once: context_project_briefing returns live git state, allowlisted project docs, open tasks, and the latest handoffs from previous agents — in one call.
The strategist decides and writes precise orders into durable task records.
Coding agents execute, picking up structured handoffs (context_handoff_create / resume) instead of re-exploring. A fresh agent resumes work without a human re-explaining anything.
Results come back labeled. Every fact Consistorium returns carries provenance: live_observation = read from git right now; agent_record = what a previous agent claimed when it left. The strategist reasons over reality, not vibes — and when an agent’s claim disagrees with git, the label makes the disagreement visible.

The division of labor is simple: the general sees; the troops code; nobody’s meter runs on orientation anymore.

Why not just give the agent everything?

Claude Code already has the repo — that was never the gap. The gap is the model outside the harness. And the naive fix — cloning the whole repo into a chat session — copies megabytes of context you can’t bound, including files that should never leave your machine.

Consistorium is deliberately the opposite: explicit path allowlist (realpath-canonicalized), secret-file denylist (.env-class files are refused even if globs match), read-only git via hardened exec, bounded outputs with flagged truncation, loopback-only HTTP requiring a bearer token, no telemetry. The strategist gets exactly the intelligence it needs and nothing more — it executes nothing and cannot widen its own access.

One concrete run through the loop

This launch is actually being directed through Consistorium right now.

We have the product repo in one workspace and a separate launch workspace containing the distribution strategy, X copy, founder-content pack, HN draft, community plan, and case study.

From ChatGPT, I can ask for the current launch state and it reads those actual documents through Consistorium instead of relying on whatever I pasted into the conversation. Today it pulled the live strategy, saw that @TritiumAISol should carry the reactive founder distribution while @AnAIRenaissance publishes the official launch, and helped map the graphics we’d already made onto the right posts.

Meanwhile the coding agents can stay focused on implementation and launch assets rather than re-reading strategy docs just to figure out what we’re doing next.

No giant context dump. No reconstructing yesterday’s decisions. No asking a coding agent to spend its meter figuring out the marketing plan.

The strategist holds the map. The agents execute.

The honest math

We won’t pretend a number transfers to your stack. But the shape holds generally: orientation is the most expensive thing you’re asking a metered coding agent to do, and it’s the one thing your conversational model can do nearly free — if it can see.

If you’re running multiple agents and your windows keep dying, try watching where the allocation goes before buying more credits.

Consistorium is free, open source, local-first, and takes about a minute to set up: github.com/Renaissance-AI-Solutions/consistorium · npm install -g consistorium