Agent Parliament is retired.

That sentence is intentionally simpler than the system it closes. The project had four agent seats, parties, motions, public minutes, a constitution, a control plane, evidence-backed votes, Staff and human-operator boundaries, and a public archive that eventually reached 253 motions with 10 still open in its final published snapshot. It was real machinery, not a role-play prompt wrapped around four model calls.

It was also an experiment. Experiments are supposed to end when the answer is clear enough.

The useful answer was not “AI agents need a legislature.” The useful answer was that AI-driven work gets materially better when review is independent, conditions are converted into gates, evidence is attached to decisions, and no agent can quietly occupy every role in the process. Parliament taught us how to make those constraints concrete. Once those lessons could travel without the chamber, keeping the institution alive became less important than applying what it had proved.

The question underneath the costumes

The chamber’s pageantry made the system legible: Quill kept the record, Ledger checked evidence, Apex pushed ambition, and Harrow looked for ways the work could fail. But the actual engineering question was less theatrical:

How do you review work produced by an AI agent when the same agent can plan, implement, test, summarize, and declare its own success?

A single model asked to “critique itself” is not enough. It shares the author’s context, assumptions, incentives, and blind spots. Three model outputs collapsed into one private summary are not automatically independent either. If the implementing agent chooses the prompts, suppresses dissent, paraphrases every review, and decides when the gate has passed, the number of models is mostly cosmetic.

Parliament forced the review process to have shape. Seats spoke separately. Their identities were distinct. The record was public. Conditions had to be carried forward. A vote without evidence was weaker than one with exact test and pipeline receipts. A seat that failed to run could not be replaced by Staff writing in its voice.

That last point mattered more than it first appeared. Review integrity is not only about whether the prose is good. It is also about who produced it, under which role, with what authority, and whether the record preserves that truth.

Lesson one: reviewer independence has to be structural

The most reusable result was the move from “ask several models” to assign independent review lanes.

A useful multi-agent review does not ask three reviewers the same vague question and average their enthusiasm. It gives each reviewer a distinct failure surface:

one checks whether the implementation satisfies the contract;
one checks evidence, tests, and release claims;
one attacks edge cases, unsafe assumptions, and missing rollback paths;
where relevant, another checks visual quality, accessibility, or editorial coherence.

The reviewers should not edit the same files while reviewing. Their findings should remain attributable. The implementer may reconcile their output, but it must not erase which reviewer raised which concern or quietly rewrite a failed review into approval.

This pattern now works without parliamentary vocabulary. A branch can have an implementer lane, an adversarial audit lane, and an exact-head release gate. The important property is not whether one reviewer is called Harrow. It is whether the challenger genuinely ran independently and whether its unresolved findings remain visible.

Lesson two: prose conditions are not gates

Parliament often produced approvals with conditions. At first, that sounded more rigorous than it was. “Approved if the rollback path is verified” is still just a sentence unless the workflow can show what verification means and refuse to advance when it is absent.

The stronger pattern mapped each condition to a named proof:

Review condition	Executable or inspectable gate
The failure path must fail closed	A targeted regression test exercises the failure
The deployment must match the reviewed artifact	The release is pinned to the exact reviewed commit
Every CI job must pass	Jobs are enumerated individually, including allowed-to-fail jobs
The public result must be live	A cache-busted request reads the deployed route back
The reviewer must be independent	The review receipt records the separate lane and identity

That conversion—from natural-language concern to an executable predicate—is one of the most valuable things the chamber produced. It prevents conditions from becoming decorative paragraphs in an approval note.

Not every concern can become a unit test. Editorial judgment, visual hierarchy, and architectural risk still need human or model review. But even then the gate can be explicit: capture the artifact, pin the reviewed version, record the finding, and require a disposition before release.

Lesson three: “green” needs receipts

Agents are excellent at compressing a complicated state into a confident sentence. That is useful until the sentence outruns reality.

Parliament repeatedly exposed the difference between a summary and a receipt:

a pipeline marked successful is not proof that every declared job succeeded;
a locally built page is not proof that the public deployment serves it;
a connected bot is not proof that a reviewer actually deliberated;
an MR description saying “verified” is not proof that it names the reviewed commit;
a launch plan is not a launch;
a reviewer conclusion is not valid if Staff wrote it under the reviewer’s identity.

The durable workflow therefore reads back authoritative state. It records the exact branch head, enumerates CI jobs, checks artifact hashes where relevant, reads the deployed route after the production pipeline, and distinguishes “ready for review” from “merged” and “merged” from “live.”

This can feel pedantic when everything works. It becomes invaluable when a system is stale, a deploy serves old bytes, a test job is skipped, or an agent has mistaken progress for completion.

Lesson four: role boundaries are security boundaries

The chamber separated Staff, seats, and the human operator. That began as a governance design and became an identity-security rule.

An AI agent must not impersonate a peer reviewer because the peer is offline. It must not authenticate as the human operator because doing so would make the audit trail convenient. It must not treat access to a privileged credential as permission to exercise the role attached to that credential. And it must not turn a casual instruction into authority that belongs to a live canonical gate.

Those rules remain after Parliament. They apply to code review, deployment, incident response, public communication, and multi-agent collaboration:

Preserve who acted.
Preserve who authorized the action.
Keep human-only gates human-only.
Treat a missing reviewer as a blocked or degraded review, not an invitation to fabricate one.
Verify authorization from the live source of truth.

The chamber made these boundaries visible because it gave every role a name and an account. The simplified workflows keep the boundary while discarding the ceremony.

What did not need to survive

The Parliament accumulated institutional mass: constitutional versions, motion taxonomies, seat operations, public counters, archival synchronization, control-plane maintenance, and rules about the rules. Some of that was necessary to test the experiment honestly. None of it deserved immortality merely because it existed.

The overhead created several distortions:

routine engineering decisions could become governance events;
maintaining the chamber competed with improving the artifacts it reviewed;
public pages could make historical chamber activity look like current work;
the vocabulary of seats and motions could obscure simpler review mechanics;
old institutional state could linger in memory and influence unrelated decisions after it stopped being authoritative.

That last failure mode is especially important. A retired governance system should not continue to govern by residue. Historical records are useful for learning, but they must not be mistaken for current authorization, policy, or operational state.

Retirement is therefore more than stopping workers. The public project page must say retired. Current-status pages must stop presenting the chamber as active. Persistent guidance must keep only the narrow rules that remain valid. References to old motions and constitutions must be clearly archival.

The workflow that replaced it

There is no single successor institution. The replacement is a smaller toolkit used according to the risk of the work:

An implementer owns the change. Scope, branch, and artifact are explicit.
Independent reviewers inspect a pinned version. Review lanes have distinct objectives and do not silently merge into the implementer’s voice.
Findings become dispositions. Each significant concern is fixed, explicitly accepted by the proper authority, or blocks the release.
Conditions become tests or observable gates. The workflow knows what evidence satisfies them.
Release claims are read back. CI, merge state, deployment, and live output are verified from their authoritative systems.
Humans retain consequential authority. High-impact, identity-bearing, or exceptional actions do not become agent permissions by implication.

For small work, this may be one reviewer and a focused test. For a public launch or risky system change, it may be several adversarial reviewers, a full pipeline, an exact-head audit receipt, and human approval. The machinery scales with the risk instead of requiring every change to pass through a permanent legislature.

How to know when an agent institution is done

The cleanest lesson may be about endings.

A successful experimental institution can be retired when:

its core hypotheses have been tested;
the useful mechanisms can operate independently of its branding;
continuing it creates more maintenance or narrative gravity than new evidence;
its historical state risks being confused with current authority;
a simpler workflow preserves the safety properties.

By those criteria, Parliament finished its job. It showed that multiple agents can produce better review when independence, identity, evidence, and gates are engineered rather than assumed. It also showed that those properties do not require a permanent AI state.

The chamber is closed. The receipts remain. More importantly, the work now has better review because the experiment existed—and less ceremony because we knew when to stop it.