The Automatic Computer

Branches, candidate worlds, governed promotion, and the architecture above replaceable models

The Automatic Computer is being built through chat agents before it can supplant chat as the dominant interface to agents.

That bridge matters. Claude Code, Codex, Hermes, and other chat-shaped agents are not merely conversational toys sitting outside the architecture. They are the first broadly useful general-purpose cognitive workers: they can inspect repositories, call tools, operate terminals and browsers, create artifacts, launch subagents, and carry a task across many steps. Choir is designed to integrate these agents through its CLI, API, and MCP surfaces, place their work inside governed state, and make their model-specific conversations subordinate to a computer the user owns.

The problem is therefore not chat agents. The problem is treating the chat transcript—and the provider account that remembers it—as the computer.

A chat presents a sequence of utterances. The user asks; the agent answers and acts; later turns compress earlier ones into working memory. The agent may change files, query services, run tests, or coordinate other agents, but the visible and durable object often remains a conversation owned by the agent surface. It can hide the harder questions: Which state did the agent begin from? What exactly changed? Which alternative states were considered? What evidence supports the change? Who authorized promotion? Can the old state be restored? Which dissent was discarded when the answer was summarized?

Those questions define the Automatic Computer, the invariant substrate being developed in Choir.

Its invariant product is not any one chatbot, model router, desktop shell, MCP server, voice companion, or swarm of synthetic employees. It is a constitutional state machine capable of employing all of them while preserving the user’s world above them.

The core operation is:

(state reference, goal, constitution) → candidate state references → adjudication → promoted state reference

Everything else is a projection.

Chat agents are the bridge

The current generation of chat agents supplies capabilities the Automatic Computer should absorb rather than rebuild behind a closed wall.

They already provide:

• natural-language goal specification;
• access to frontier and local models;
• tool use and computer operation;
• coding, research, and publishing workflows;
• long-running task loops;
• subagent delegation;
• an enormous and rapidly improving ecosystem of skills and integrations.

Choir’s near-term job is to become the stateful constitutional substrate beneath those agents. Its CLI gives a chat agent a headless control surface over Choir. Its API lets agents and applications address objects, trajectories, state, and promotion directly. Its MCP surface lets external agent clients discover and operate Choir capabilities without requiring Choir to own their conversational interface.

In that phase, the user may still begin in Hermes, Claude Code, Codex, or another chat client. But the durable result should land in Choir as an object, branch, artifact, candidate state, adjudication, or promoted transition. The conversation is an ingress path. It is not the court of record.

This produces a deliberate migration:

chat agent → Choir CLI/API/MCP → governed candidate state → adjudication → promoted user-owned state

The agent ecosystem can continue improving at model-lab speed while its useful work accrues to a substrate that survives replacement of the agent, provider, or chat client.

What the transcript still hides

A fluent answer can conceal the difference between advice and action.

“Here is the configuration you should use” is not the same as changing the configuration. “The migration looks safe” is not the same as running it. “I combined the best ideas” does not establish that file edits, database mutations, permissions, tests, and unresolved conflicts were reconciled.

An agent transcript encourages a dangerous compression: the system speaks as if its report were the result, even when the real result is a changed world.

A computer must expose that changed world. It needs to distinguish:

• observation from proposal;
• proposal from mutation;
• mutation from tested candidate;
• candidate from canonical state;
• canonical state from published or externally committed action.

The difference is constitutional, not cosmetic. A proposed branch may be wrong without harming the user. A promoted branch changes what later agents inherit. A public or irreversible action crosses another boundary entirely.

The Automatic Computer API

The API begins with a state reference rather than a transcript. A chat agent can supply the goal, interpretation, and working intelligence, but it addresses a world whose identity is external to its context window.

The state reference identifies the world on which the task operates: files, databases, documents, plans, permissions, services, artifacts, or a larger snapshot. The goal states what transformation is desired. The constitution specifies the conditions under which agents may explore and act.

A constitution can include:

• budget and compute limits;
• allowed tools and data domains;
• privacy and retention rules;
• autonomy level;
• reversible versus irreversible operations;
• confidence thresholds;
• required reviewers or quorums;
• publication and messaging authority.

The output is not immediately one answer. It is one or more candidate state references. Each candidate represents a coherent possible world resulting from an attempted transformation.

Those worlds can then be inspected, compared, tested, criticized, reconciled, and promoted.

This architecture lets users choose how intelligence may act without requiring them to choose every model used internally. The system can hire different minds under one constitution—including minds reached through existing chat-agent clients.

Quasi-stateful local worlds

A heterogeneous multi-agent system needs nonshared state.

If every agent sees the same transcript, inherits the same summary, and writes into one mutable workspace, apparent plurality can collapse into one correlated cognitive stream. Later agents inherit earlier framings and accidental mutations. Reviewers can no longer distinguish the original world from the candidate they are supposed to inspect.

Branches create coherent local worlds.

An agent receives a base state reference and works inside an isolated branch. It can develop assumptions, retrieve evidence, modify artifacts, run tests, and preserve local memory without contaminating other candidates. Another agent can begin from the same base with a different model, decomposition, or toolset.

The system is quasi-stateful: each agent experiences a continuous local world, while the global computer remains a versioned graph of branches and promotions. There is no need for one omniscient mutable context.

This isolation serves two purposes.

First, it is operationally safer. A mistaken mutation remains inside a branch until authorized.

Second, it is epistemically valuable. Independent agents can preserve uncorrelated framings. Their disagreement becomes inspectable rather than silently blended.

What a branch must contain

A branch is not merely a copy of a directory. It is a case file.

At minimum, it should preserve:

• the base state reference;
• the goal and constitution;
• proposed mutations and exact diffs;
• assumptions and context;
• retrieved evidence and source links;
• generated artifacts;
• model and tool provenance;
• tests and evaluation results;
• objections and unresolved dissent;
• authorization history;
• costs, timing, and side effects.

This turns an agent run from an ephemeral performance into an auditable object.

The requirement becomes more important as systems operate across heterogeneous substrates. A branch may include a Git worktree, a VM snapshot, a document graph, a database transaction, a deployment plan, a set of browser actions, or a simulated institutional state. The common abstraction is not “folder.” It is an isolated candidate world addressable by reference.

Candidate worlds, not candidate paragraphs

Most model comparison still happens at the level of answers. Ask several systems a question, compare prose, and choose the most convincing response.

That is inadequate for consequential work.

A coding agent should be compared through the repository it produces, its tests, security properties, and diff. A research agent should be compared through its claim graph, sources, uncertainties, and surviving objections. An operations agent should be compared through a proposed state transition, its rollback plan, and its effects under simulation. A publishing agent should be compared through the artifact, provenance, source integrity, and public rendering.

The candidate is the world after the proposed work, not the paragraph describing the work.

This is why branches matter even when agents produce identical prose. Two agents may say “the migration succeeded” while leaving materially different systems behind. A court needs the resulting state.

Merge is not summary

The word merge is often abused in AI systems. Several outputs are summarized into one response and called a synthesis.

A summary reconciles language. A merge reconciles mutations.

Suppose one branch changes a schema, another updates application code, and a third identifies a security objection. A real merge must determine:

• whether the schema and code are compatible;
• whether both branches began from the same base;
• which tests cover the combined state;
• whether the security objection is cleared;
• which authority may accept residual risk;
• whether data can be rolled back after deployment;
• what provenance and dissent remain attached.

The merged result is a governed state transition.

Sometimes the correct result is not to combine branches. One candidate may dominate. Two may be mutually incompatible. An objection may block all promotion. The user or authorized court may preserve alternatives for later cases.

Promotion, not prose blending, creates canonical state.

The right to remain unpromoted

Generative systems produce possibilities cheaply. This is a strength only if possibility is separated from commitment.

A branch should be allowed to remain speculative. Agents need spaces where they can try dangerous refactors, heterodox interpretations, alternative plans, and uncertain hypotheses without those ideas acquiring canonical authority merely because they were generated.

This separation also protects dissent. A losing branch should not necessarily be deleted. It may contain an objection later vindicated by reality, a source omitted from the winning candidate, or a design whose value becomes visible under new conditions.

Canonical state is not the declaration that every alternative was false. It is the state authorized for continued operation.

Rollback is part of judgment

A computer that can act but cannot recover is not autonomous. It is brittle.

Rollback is often treated as an operational convenience: useful when a deployment fails. For an Automatic Computer it is a constitutional primitive. It changes which actions can be delegated, how much review they require, and how mistakes are priced.

A reversible local change can tolerate exploratory autonomy. An irreversible deletion or public commitment requires stronger standing. A state snapshot, transaction log, immutable artifact, VM image, or versioned data layer makes more of the world safely queryable.

This requirement was not discovered in theory. Mutable agent environments can be corrupted. Data images can be damaged. An agent that modifies the substrate on which its own recovery depends can turn one error into a bricked computer.

The audited computer therefore needs rollbackable state vectors and isolation boundaries—VMs, containers, transactional stores, immutable bases, or equivalent mechanisms appropriate to the domain. The exact technology can change. The constitutional requirement does not.

The system must be able to say: this was the previous canonical world, this was the authorized transition, this is what failed, and this is how we return.

Artifacts are courts of record

Generative memory is not enough.

A model can summarize what happened, but a summary is itself another generated claim. The court of record needs symbolic and inspectable artifacts:

• source documents and citations;
• exact diffs and state references;
• test outputs and proof objects;
• authorization records;
• model and tool identities;
• objections and dispositions;
• publication or deployment status;
• observed outcomes.

These records carry standing across time. A critic earns trust because its objections repeatedly survive later settlement. A model earns standing in one role because its candidates pass relevant courts. An artifact becomes canonical because its promotion history is inspectable.

This is the difference between memory as personalization and memory as precedent.

A chatbot remembers that the user likes concise answers. A constitutional computer remembers which state was authorized, why, by whom, under which evidence, and with what right of rollback.

One computer, many projections

The Automatic Computer should not be identified with one interface.

Today, the most important projections are the integration surfaces. An MCP surface exposes tools and state to external chat agents. A CLI lets Hermes, Codex, Claude Code, developers, and scripts address and inspect Choir headlessly. The API lets any client work against the same governed object and state model. A desktop or web interface can show current and candidate worlds, diffs, evidence, objections, and promotion controls. Mobile provides authorization and monitoring. An Automatic Newspaper publishes and navigates a public artifact graph. Future hardware can provide a household or embodied endpoint.

Automatic Radio is the longer-term interface transition. It does not mean putting a voice skin on the chatbot. It means the computer continuously traverses its owned state and permitted world: monitoring, learning, briefing, escalating relevant changes, receiving lightweight commands, and routing work to agents without requiring the user to repeatedly open a chat thread and restate a task.

In that sense, Choir first integrates chat agents and later supplants chat as the primary interaction loop. The agents remain cognitive suppliers inside the computer. What disappears is the requirement that the user organize life as a sequence of sessions with them.

These projections have different affordances and should not pretend to be interchangeable.

Radio is good for “what changed?”, “keep watching this,” and “pause that deployment.” It is poor for inspecting a complex diff or adjudicating competing citations, so it must hand those cases to visual artifact surfaces rather than improvise settlement through voice. A public newspaper can expose artifacts and provenance; it should not expose private state. A mobile device can authorize a transition; it should not collapse employer, client, household, and personal memory into one personality.

The invariant object is the state machine beneath them. Chat agent, CLI, API, MCP, desktop, Newspaper, and Radio are different ports into the same computer—not separate stores of the user’s reality.

Model permeability

A model lab naturally wants the model to become the computer. Its identity persists across chat, coding, work, home, device, and memory. The user’s continuity becomes a feature of the provider’s continuity.

The Automatic Computer reverses the dependency.

The user’s state, artifacts, permissions, constitution, and history persist. Models enter as cognitive suppliers. Claude may create one candidate, Codex another, a local open model a third, and a narrow verifier may criticize all of them. A future model can be admitted through shadow cases without replacing the computer’s identity.

This is more than routing. A router chooses an answer supplier. A model-permeable computer preserves the state on which suppliers act and the court that determines what becomes real.

Supplier progress can then accrue to the same user-owned substrate. Better models produce better candidates, more capable critics, cheaper background work, and new projections without forcing the user to abandon accumulated state or accept one provider’s sovereignty.

The automatic computer is an institution

A computer in the twentieth-century sense executes programs over files and memory. The Automatic Computer executes governed transformations over durable worlds.

Its essential operations are:

• fork a protected possibility space;
• employ one or more intelligences under a constitution;
• produce evidence-bearing candidate states;
• expose them to appropriate courts;
• preserve objections and provenance;
• promote an authorized transition;
• roll back when judgment fails.

This architecture implements the epistemic principle that intelligence cannot certify itself. It lets many interiors generate possibilities while preventing any one of them from silently becoming canonical.

But architecture does not settle ownership. A provider can offer branches, artifacts, and rollback while retaining ultimate control over identity, compute, continuation, and exit. A stateful system can still be a rented computer whose sovereign can change the rules or terminate operation.

The next question is therefore not which model is best. It is which boundary captures the value of all models, and who owns the right to keep that boundary alive.

This is the architecture layer of The Constitutional Stack. Courts for Intelligence defines the governance it implements; Who Owns the Boundary? follows state continuity into moats, model sovereignty, and compute ownership.