Platform · control layer
How the workspace controls itself.
Five agents on this site do work you can see: they measure citations, write articles, publish them, fix the site, make the covers. Eight more exist only to keep those five honest. They route the request, compile the rules, run the gates, keep the memory, write the handoff and cap the spend. Nobody buys them, which is exactly why almost nobody publishes them.
We read the live capabilities on 22 July 2026: 7 of the 8 report healthy and 1 runs in shadow, which means it records what it would have decided without enforcing it. We are publishing the design and current status, not a claim that it is finished.
Read 22 July 2026
8 modules in the control layer · 7 healthy, 1 in shadow · none of them sold separately.
Why this works
Where agent stacks go wrong.
An agent stack fails in three ways, and none of them look like failure at the moment they happen.
It is confidently wrong and nothing notices. The output reads well, the number in paragraph four is invented, and it ships. Fluency is not correctness, and no amount of prompt quality substitutes for a check that runs after the fact on the actual artifact.
It forgets. Each session starts from zero, re-solves a solved problem, and contradicts a decision made three weeks ago that nobody wrote down. The second month then costs what the first month cost.
It spends without a ceiling. A trivial request loads the heavy tooling because the heavy tooling was always on. The bill grows in a way nobody can attribute to a decision anyone made.
What changes with a control layer is not that agents stop making mistakes. It is that a mistake produces a failed gate and a handoff instead of a published page, and that the decision behind it survives the session in which it was made.
The layer
Eight agents, with their real statuses.
We took every version and status below from live capability reads on 22 July 2026. The same control plane routes and proves this site update. A ninth platform agent, MailOps, turns email into workspace packets and belongs to the workflow side rather than to this layer.
| Agent | Version | Live | What it does |
|---|---|---|---|
| Workspace Orchestrator | 0.2.1 | healthy | Classifies the request, projects authority, builds the execution plan, and records which modules must produce proof. |
| Agent Governance | 1.1.0-shadow | shadow | Compiles project rule packs and records the winning and shadowed rules without enforcing the outcome yet. |
| Proof Loop | 0.1.0 | healthy | Runs task-relevant tests, static analysis, visual baselines, and golden gates before work is called done. |
| Workspace Memory | 0.1.0 | healthy | Keeps sourced decisions, accepted artifacts, install proofs, and audit facts for later sessions. |
| Workspace Files | 0.1.0 | healthy | Owns shared artifact paths, checksums, and delivery proof for files an operator can actually open. |
| Handoff Continuity | 0.1.0 | healthy | Records exact continuation state, proof, blockers, and the next executable action across sessions. |
| Token Profile Router | 0.1.0 | healthy | Selects the smallest safe tool profile and keeps heavy tooling opt-in for a stated reason. |
| Proactive Controller | 0.1.0 | healthy | Suggests safe preflight work and stale-install checks without publishing, sending, deleting, or mutating credentials. |
The one to look at twice is Agent Governance, sitting at shadow. It compiles the rule packs and records which rule would have won without enforcing the outcome. That is the correct order: a governance layer earns the right to block work by first being observed making decisions somebody can disagree with.
One request, start to finish
Six things happen before anyone reads the output.
01 · Route
The request gets a plan
The orchestrator classifies what was asked, decides which agents are involved, and writes down the plan before any of them run. An operator does not have to know the stack to use it correctly.
02 · Budget
The tool profile is chosen
The token router loads the smallest set of tools the task needs. Heavy parsing and browser tooling stays opt-in, so a simple request does not quietly pay for a complicated one.
03 · Rules
The pack is compiled
Governance assembles the rules that apply to this project and records which won and which lost, so a decision can be explained months later instead of re-argued.
04 · Work
The agent does the job
Only now does the content, visibility or design agent run. Everything before this point exists so that what it produces can be trusted without reading every line of it.
05 · Prove
The gates run
Proof Loop executes the checks the task actually calls for and produces a receipt. Work that cannot pass returns an operator handoff, not a quieter version of itself.
06 · Remember
The result is filed
Memory keeps the accepted artifact and the decision behind it; Handoff Continuity writes the note the next session reads. That is why the second month does not repeat the first.
Honestly
What this layer does not give you.
It is not a compliance product. There is no certification behind it, no auditor has looked at it, and it makes no claim about any regulatory framework. It is engineering discipline expressed as software, which is a different and smaller thing.
It does not make agents correct. It makes them checkable. A gate catches what a gate was built to catch, and every gate in it exists because something got through once. New failure modes will arrive and the honest response is a new gate, not a claim that the set is complete.
It is early-stage, and one part enforces nothing yet. The version numbers and statuses on this page are not decoration. If you are choosing a vendor on the maturity of its internal tooling, this page is evidence of direction rather than of arrival, and we would rather you read it that way than be surprised later.
Take this with you
Four questions for any agent stack.
Including ours. A vendor who cannot answer these has not built a control layer, whatever the feature list says.
- What runs after the model produces output? If the answer is a human review, ask who reviews at forty items a month. If the answer is nothing, the fluency of the output is the only quality control there is.
- What survives between sessions? Ask to see where a decision made three weeks ago is stored and how the next run finds it. Chat history is not memory, because nothing reads it back.
- What can it do without a person, and what is it forbidden to do? A system that can publish, send and delete unattended is a different risk from one that can only suggest. Both are defensible; not knowing which you bought is not.
- What happens when a check fails? The useful answer is that the work stops and comes back to a person. The answer to worry about is that it degrades quietly to something that passes.
Questions this page invites
About the control layer, answered directly.
Are these agents I can buy?
No. This is internal machinery, not a product line, and there is no price list for it. It appears on this page because it is the reason the client-facing agents can be held to a standard, and because a buyer evaluating an agent stack deserves to see whether one exists at all.
What does "shadow" mean next to Agent Governance?
It compiles the rule packs and records which rule would have won, without enforcing the outcome. Running a governance layer in shadow first is how you find out whether its decisions are any good before it starts blocking work. It is honest to say that is where it currently sits.
All of these are MVP. Why publish them at all?
Because the alternative is a page that claims a maturity we do not have. 7 of the 8 report healthy on the live workspace as of 22 July 2026 and 1 runs in shadow. What is worth publishing is the design and current status, not a claim that it is finished.
What stops an agent from doing something irreversible?
Scope, not good intentions. The proactive controller can suggest and cannot publish, send, delete or touch a credential. Anything with a side effect runs through a gate that produces a receipt, and work that cannot pass its gates comes back as a handoff to a person.
Why does memory matter more than it sounds?
Because an agent stack without it re-solves the same problem every session and quietly contradicts its own earlier decisions. Keeping the accepted artifact together with the decision and its source is what makes month two cheaper than month one instead of the same price again.
Do competitors have this layer?
Some have parts of it internally. What is unusual is publishing it, including the statuses that are not flattering. Being checkable beats being impressive, and this page is the clearest test of that we have.
Judging an agent stack? Ask it these questions.
What runs after the model produces output? What survives between sessions? What can the system do without a person, and what is it forbidden to do at all? Thirty minutes, and the answers are more useful than any feature list.