What Madebook is

Madebook is a control plane for teams whose code is written by AI coding agents. It sits above the tools your engineers already use — Claude Code, Codex, Cursor, Copilot — and it does not replace any of them.

Madebook does not generate code. It does not host source. It does not manage a backlog and it is not an editor. It owns the things none of those tools can see from where they stand: what is currently true about the codebase, what the team has already decided, what the organization forbids, what each agent was told, what each agent actually changed, and what a human still needs to look at.

The problem

Running several coding agents at once creates a distributed-systems problem inside an engineering team.

Each agent holds its own snapshot of the repository, taken at a different moment, and nothing reconciles them. The expensive failures leave no trace in git — no overlapping file, no changed signature, nothing to conflict at merge. That is why every tool that watches pull requests misses them.

Three shapes this takes, all of which Madebook detects:

1. A decision the agent never saw. One engineer's agent picks a 60-minute token expiry. Another's picks 24 hours. At 10:07 a person decides that externally emailed security tokens expire after 30 minutes. The second session was briefed at 10:05. It is now building against an answer the team has replaced, and nothing in the diff says so.
2. Architecture quietly forking. One agent adds Redux and starts migrating state. Another keeps building with React Query, as it always has. Both branches work, both test suites pass, neither touches the other's files — and the codebase now has two state-management approaches chosen independently by two machines that were never told the question had been settled.
3. A rule the agent had no way to know. The agent needs an environment variable, so it adds .env loading. Reasonable. Your governance says secrets come from a key vault. It is written down, and it was never in the prompt. The diff is clean, idiomatic, well tested, and wrong for this company.

What Madebook does about it

Madebook applies constraint at three moments.

Before. Every agent starts from what is currently true. Architecture rules, decisions already made, standards, security rules, the mission contract and the current state of the repository are assembled into one brief, and the agent gets it before it writes anything. A constraint applied at the start costs nothing. The same constraint applied at the pull request costs the whole branch.

During. When one agent invalidates another, the other one is told. The detection is a join, not a judgement: what one session moved, against what another session is standing on. It is deterministic, explainable, and cheap enough to run on every report. A session whose ground has moved is re-briefed — or held — while there is still time for that to matter.

After. What actually happened is recorded separately from what was claimed. An agent may report what it did. It may not certify it. Reported, observed and attested are three different things and are stored as three different things, so "the tests passed" from an agent and "the tests passed" from CI never quietly become the same sentence.

The loop

Organization governance ─┐
Workspace context          ├─► brief ─► MCP ─► work session
Architecture rules       │                      │
Mission contract         ┘                      ▼
                                        change reported
                                               │
                    ┌──────────────────────────┼──────────────────┐
                    ▼                          ▼                  ▼
            architecture deviation     collision radar        policy triggers
                    └──────────────────────────┼──────────────────┘
                                               ▼
                                       risk assessment
                                               ▼
                                 evidence requirements + gate
                                               ▼
                                        review capsule
                                               ▼
                                       attention queue

Every arrow in that diagram is a page in this manual.

The objects you will work with

Object	What it is
Organization	The tenant. Every row in Madebook carries an organization. People, roles, governance and billing live here.
Workspace	A body of work inside an organization. It holds its repositories, its context, its rules and its missions.
Repository	A connected code host repository. Madebook reads it; it never writes to it.
Context (the brain)	What is true about this workspace — technologies, standards, security rules, known problems. Derived from the code, then confirmed by a person.
Architecture rules	The constitution: the rules the codebase actually follows, derived from the code and approved by a lead.
Decision	A choice the team made, with the scope it applies to. Reaches an agent on its next brief.
Mission	The outcome Madebook holds work to, with a contract that says what "correct" means.
Work session	One human intent, opened by an agent through the MCP and closed when it is done.
Change	What a session changed — files, symbols, dependencies — with its risk, its evidence and its review capsule.
Attention item	One thing that needs a person, with what it is and what the next move is.

Three of those nouns are easy to confuse, and they are not the same noun:

• A source item is the ask as the source wrote it — a Jira story, a ClickUp task, a pasted paragraph.
• A mission is the outcome Madebook holds work to, with the contract that says what correct means.
• A work item is one step of a mission's execution plan — the concrete technical change an agent worked out after reading the mission and the repository.

What it refuses to do

These make Madebook look worse in a demo. They are why it is worth trusting six months in.

• It never says "ready to merge." It says who checked what, and what nobody checked.
• Silence is never green. A check that did not run reads as absent, not as passing.
• The diff outranks the agent. Where the report and the diff disagree, the diff wins.
• Nothing is invented. A field with no evidence behind it stays empty rather than plausible.
• Nothing generated is presented as fact. Model output is stored with the model's name and a full manifest of what it was given and why each item was chosen.
• Read-only against your repositories. No writes, no branches, no pull requests, no merges.
• Your source is never stored. Files are fetched, used, and dropped. Madebook keeps paths, sizes, roles, modules, symbols and manifests.

Where to go next

1. Signing in — Madebook uses your shared Bookbag account.
2. Organizations — the tenant, and where people are managed.
3. Roles and permissions — the four roles and the exact capability table.
4. Creating a workspace — the wizard, step by step.
5. Connecting a coding agent — the part your engineers do.