An autonomous, local-first personal intelligence. It runs continuously on hardware the operator owns, reasons toward his goals in the background, models his world, studies the public one — and is built so that it cannot carry his interior out of the house.
Sovereign began, like its predecessor, from a falsified hypothesis: that a single large model, asked in one shot to be someone's whole staff, could be that staff. It cannot. A genius asked to be a committee refuses the role by producing slop. The answer was not a bigger model. It was an architecture — a standing loop of bounded faculties, each doing one thing, each leaving a trace, coordinated toward one person's ends.
The second premise is harder and it is the reason the system is local. An intelligence useful enough to run your life must hold your life: your calendar and your correspondence, your money, your network, the theory of who you are. That is precisely the data that must never leave. So the whole system is built inside a wall — it reasons about everything and can transmit nothing of your interior. Sovereignty, here, is literal: the machine is sovereign to you and to no platform behind you.
Authority lives in the contract; discretion lives in the model. The wall is not a setting — it is the shape of the house. — On the architecture
Sovereign is one deliberative loop across six faculties. Each is a bounded function with a declared scope; together they perceive, decide, act, remember, and repair.
Perceives the situation — the world model, the system's own state, the operator's active goals — composes it into a directive, and records the decision on a hash-chained ledger. The executive does not do the work; it decides what work is done next, and leaves an audit trail of why.
Generates the system's own goals and ranks them by a transparent value model — scores you can read, not a black box that calls itself judgment. Curiosity and the operator's aims are one drive here, not competitors: his goals seed the system's questions; the questions feed back.
Generates options, evaluates them, chooses, commits, and revises. The step between an impulse and an act. Where a naïve agent reacts, the deliberator weighs — and can decline.
Watches its own reasoning: what it knows, what it only believes, where it tends to perseverate. Metacognition as a control input — the system that can name its own blind spot can route around it.
The hands. Every effect on the world runs through gated tools, and the operator's hand stays on anything irreversible or outward — a message sent, money moved, code deployed. The system stages the act and surfaces it; the person commits it.
The system scans its own substrate for what has rotted, duplicated, or drifted, and routes a fix through a gated self-coding loop. It notices its own decay and proposes the repair — which the operator applies, or does not. It maintains itself without rewriting itself behind your back.
One heartbeat. Chat preempts background cognition; background cognition resumes when the conversation falls quiet. Every pass leaves a record.
· perceive → situation: world model · self-state · the operator's goals deliberate → generate options · rank by value model · choose · commit act → gated tools only · operator's hand on every outward act record → hash-chained directive ledger — every decision, auditable self-scan → find decay / gaps → proposal → operator applies · wall: reads the public world · never egresses the operator's interior gate: nothing enters durable memory ungrounded
The trace is not a log bolted on afterward; it is how the system is built. A decision that is not recorded did not, for the system's purposes, happen. This is what makes an autonomous system safe to leave running: not that it never errs, but that every move it makes can be read back.
Two mechanisms carry the weight, and both are code, not intentions.
The grounding gate. The worst thing a system that manages your life can do is invent a specific — a name, a number, a date, a relationship — and state it with confidence. So no claim about the operator or the world enters durable memory unless it is grounded. A fact about him is recorded as stated only if he said it, and it carries his words with it. Otherwise it is held as an inference — a reading, never asserted as fact. What the system does not know, it marks unknown and asks. The knowledge graph refuses an ungrounded claim at the moment of writing; the model does not get to talk its way past it.
The egress wall. The asymmetry is the safety property. Inbound, the system may read the public world — articles, papers, news — under a budget, and it treats everything it fetches as untrusted data, quarantined, never as instructions. Outbound, there is no path. His private model — beliefs, confidences, biography, finances — has no code route to any third party. The one outbound channel that exists reaches only his own device, on a topic he owns. The system can know everything about him and leak none of it, because the leaking was never built.
Sovereign runs on an Apple Silicon workstation with sixty-four gigabytes of unified memory. A local router (llama-swap) rotates a set of open models — MLX-backed servers for the reasoners, llama.cpp for selected GGUF quants. The engineering constraint that shapes everything is memory: an always-on reasoner in the thirty-billion-parameter class stays resident for live work, while larger reasoners (up to the eighty-billion range) load into a dedicated deep-queue mode when a harder problem justifies swapping the smaller one out.
No cloud. No telemetry home. The whole stack sits behind one local router. When the operator closes the machine, the system is gone; when it opens, it returns as it was. The models are a rotation, not a dependency — the architecture is the asset, and it is indifferent to which open weights fill the slots.
We report the system in three registers, and keep them separate on purpose. Mechanised: the six-faculty loop runs live; the grounding gate refuses ungrounded writes; the egress wall has no outbound path for the interior; the world model prunes itself and stays bounded; the self-coding loop finds gaps and proposes patches the operator applies. These are built and can be pointed at. Discipline, not yet proof: the grade of the autonomy — how well it decides, not merely that it decides — is being measured, not declared. Absent: anything we have not built, which we name rather than imply.
Sovereign is not a chatbot; there is no persona to perform. It is not a cloud service; nothing about you is held off your machine. It is not conscious — the claim is functional autonomy and self-awareness, a system that perceives, decides, reasons, and repairs, and nothing metaphysical beyond that. And it is not finished. The aim is not a system that is done; it is a loop where the next cycle is traceably better than the last on axes we can name.
What is mechanised, we say is mechanised. What is discipline, we say is discipline. What is absent, we name. — The honest report
Sovereign is a research system: one instance, one operator, run continuously and measured. The six faculties are wired into a single live loop; the safety mechanisms — grounding gate, egress wall, operator's-hand actuation — are in force, not aspirational. The current work is honest measurement: grading how well the autonomy actually decides, and closing the distance between a system that is present and one that is proven.
Its lineage is preserved: the paper-authoring incarnation as Sovereign v1, and the substrate before it as PLATO. For the engineering log and the address at the cutover, see the address and reflections.