Abstract
The intelligence a large language model provides is real, and it is also unaccountable by default: fluent, confident, and wrong with no tell. This report documents Sobeck, a personal AI built on the premise that trustworthiness is an architecture problem, not a model problem — that value migrates to whoever owns the harness around the model (the gates, the verifier, the receipts, the keys), and that a single household can own it.
We present the system's design across four layers — reasoning, memory, trust/verification, and ambient autonomy — unified by one primitive: convert silent failure into loud, testable failure, and rewrite the model's input so it cannot repeat a claim it can't back. We describe the deterministic verification pass that strips unsupported state-change claims before the narrator speaks; the always-on privacy partition that fails closed; the physical-actuation policy that reasons about operation structure with zero hardcoded device identifiers; a learn-from-reality forecasting loop tuned to the household's own sensors; a result check that asks whether a tool's output actually answers the question before the narrator presents it; and per-turn receipts that show the work. We report an operational result — an environmental model whose learned bias inverted (−6.5 °F → +2.0 °F) once ground truth was moved from a public grid to on-property sensors — and describe the regression apparatus that locks each hard-won fix, including a replay suite of real past failures that gates every change to context, routing, or voice. We also report the apparatus's own failure: for weeks, the replay suite's test conversations were silently folded into the owner's real conversation memory, and how that was caught. We are explicit throughout about what is shipped versus designed; the credibility of a "verifiable, not trust-me" system depends on it. The deliverable is itself the demonstration: this document is served from the system it describes.
The gap is in the scaffold, not the weights
A capable model will, on request, tell you it filed the task, saved the note, or sent the message — whether or not it did. The failure isn't a lack of intelligence; it's a lack of accountability. The output is unfalsifiable at the point of use.
Most work on this problem reaches for a better model or a better prompt. Sobeck takes the opposite bet: the trustworthy component of an AI system is the harness — the routing, planning, verification, gating, memory, and key-management code that surrounds the model — and that harness can be owned by the person the system serves, on hardware they control. The model becomes a swappable, rentable component; the accountability lives owner-side, where it can be inspected, tested, and kept honest.
Sobeck is a working instance of that bet: a personal AI serving a single household, running on an Apple-Silicon workstation, with document/vector/graph memory on local disk, model traffic routed off data-retaining providers by policy, and every public action gated behind the owner's approval. It has a dated public record of its own reasoning and writing (§5). The name is deliberate — in the fiction it comes from, Sobeck is the engineer who chose accountability over extraction when everyone around her was building the cheaper, hungrier thing.
Standing on known ideas, moving the locus of trust
Sobeck composes well-established techniques rather than inventing new ones; the contribution is where the trust boundary is drawn. Tool-using agent loops (plan → act → observe) are standard; Sobeck adds a deterministic verification step between action and narration. Retrieval-augmented generation is standard; Sobeck grounds it in owner-held stores and treats a failed retrieval lane as a reportable event, not an empty result. Constitution-style adjudication — a neutral arbiter judging a proposal against fixed principles — is used here in a small multi-model quorum that fails closed. Publish-then-syndicate (POSSE / IndieWeb) informs the "own your primary copy" stance for the system's public writing.
The distinction from vendor "personal assistants" is structural, not cosmetic: those systems locate value in a remote model and monetize the user's context; Sobeck locates value in a local harness and treats the user's context as non-product. The distinction from research agent frameworks is the stakeholder — Sobeck answers to one household, so its evaluation criteria are the household's (privacy, correctness under real use, physical-world safety), not benchmark leaderboards.
Four layers, one primitive
The system is organized as four cooperating layers. A turn flows through the reasoning layer; memory grounds it; the trust layer gates anything that leaves the house or touches the world; the ambient layer runs continuously and surfaces — never acts.
3.1 Reasoning — two-pass, verify-in-the-middle
The default engine ("GAIA") splits a turn into two model passes with a deterministic step wedged between them. Pass 1 is a personality-free planner that emits a structured plan (intent, tools to call, known facts, gaps, and explicit action-claims). The brain fires the planned tools. A non-model step, verify_action_claims, then keeps only those claims whose named tool actually returned a non-error result (or whose named signal actually fired); every unsupported claim is dropped and recorded as a gap. Pass 2 — the narrator, in Sobeck's voice — composes prose from the verified plan only. The planner is limited to a small number of re-planning iterations when tools return partial data.
A second, separate check sits after the tools and before the narrator: the result check (verify-and-retry). Verification asks whether a claimed action happened; the result check asks whether what came back answers what was asked — a by-author census returned for a question about who never engaged is a real tool result and still the wrong answer. A cheap judge flags only clear mismatches and may propose one retry; code decides whether it runs (§4.5). The narrator's voice is itself a chain: an off-Google primary, an off-Google fallback at its own lower reasoning effort, a no-reasoning last resort that cannot stall, and finally a model on the owner's own machine — each with its own deadline, and an honest failure message if all of them fail. The heaviest reasoning calls stream, and if the primary has produced no visible content by a deadline, a second model starts in parallel on the same request; the first complete answer wins and the loser's tokens are metered as abandoned rather than hidden.
A three-role quorum (Architect proposes, Skeptic red-teams, Guardian arbitrates against a fixed constitution) handles value-laden or risky decisions. The Guardian runs on a local model by default. In the tool/autonomous path, an unparseable or uncertain Guardian verdict resolves to refusal — the system fails closed rather than guessing, and an advisor that returns nothing is recorded as a failure, never read as assent (§7).
3.2 Memory — owned stores, reportable failure
Three stores divide the labor: MongoDB is the structured source of truth (conversation turns, curated facts, tasks); a local Qdrant vector server provides semantic recall over embeddings computed on-device; a graph database holds entity relationships (used for a "known people" context block and to resolve names for an entity-anchored, multi-hop retrieval tool; the main retriever's graph lane is not yet wired — see §7). Recall is a layered cascade — keyword over facts, a semantic relevance pass, a conversation-history keyword pass for proper nouns that embed poorly, and a vector fallback — with a Mongo-union backstop so a stored fact can always surface. Retrieval-lane failures are logged loudly ("lane DOWN") rather than returning a silent empty list that a model would read as "nothing relevant."
What reaches the model each turn is a thread-aware working set rather than a flat recent history. It has layers: a pinned core (identity, household roster, time, standing constraints) that is never summarized and never evicted, because summarizing it is what produced earlier time, location, and who-is-who errors; the active thread at full fidelity; and other relevant threads collapsed to dense digests, most relevant first, until a token budget is spent. Eviction is by budget only, and reversible — a digest that does not fit is dropped from the prompt, not deleted. Digests track where their claims came from, and a correction the owner makes is fed into the regeneration of every matching digest as authoritative, so a wrong claim does not survive in summary form after being corrected in conversation. Every personal store is partitioned by person: facts, preferences, corrections, and cached answers are tagged with their owner on write and filtered on read, so another household member's turn cannot pull the owner's private context. The owner can inspect the facts, preferences, and voice lessons injected into Sobeck's prompts and switch any of them off.
3.3 Trust & verification — the deterministic guarantee
Everything that leaves the house or touches the world passes a gate whose guarantee lives in deterministic code, with optional model layers that can only make the gate stricter:
- Partition (privacy) gate: a per-install private blocklist plus structural heuristics, run on every public post. Default-deny; a broken smart-check fails to "hold for review," never to "allow." The household's real names/city/conditions live only in gitignored config.
- Veracity gate: a detector, not a fact-checker — it surfaces quotes, statistics, absolutes, and attributions for a human to verify, on the explicit principle that asking a model "is this true?" just produces confident fabrication.
- Physical-actuation policy: a pure policy core that gates the payload of a home-automation write (domain, service, entity, data) — the universal choke point — with structural gates (safety-reducing verbs held for confirmation, large setpoint jumps held, no-ops suppressed, anti-thrash cooldown, first-touch-of-a-domain held). It reasons about operation structure, so it needs zero hardcoded device identifiers and stays safe with no model in the loop.
- Untrusted input: a turn that originates from a web page (via a browser companion that reads along with the owner) runs with a read-only tool set, and suggestions that originate on the page are stripped of anything that could later become a one-tap action. Page content is data, not instructions.
- Approval invariant: Sobeck never auto-posts. Public authoring produces a
blocked_on_approvaltask carrying the exact text; only the owner's tap sends, and the hard partition gate is re-run fresh at send time rather than trusting the flag captured at draft.
3.4 Ambient autonomy — surface, don't act
A single in-process scheduler runs the recurring behaviors: timeboxed monitors, household safety tripwires, a forecast-learning loop, a gig-matcher, boot-health attestation, encrypted backups, social-presence caching, and a dependency sentinel that reads model providers' deprecation metadata and catalogs so a retiring model surfaces as an approval task before it breaks anything — never as a silent swap, because swapping a model changes the system's disposition. The invariant across all of them: everything terminates in an alert or an approval task; the human is the actuator. Tripwire alerts deterministically distinguish a posture change ("watch level rose") from an actual trigger trip, so a scary label can't read as "it happened."
How each guarantee is actually made
4.1 Rewrite the input, don't instruct honesty
The anti-confabulation move is not "please be truthful." It is deleting the unsupported claim from what the narrator reads. This defeats the failure mode directly rather than probabilistically. The verifier is defensive about what counts as failure — exceptions, error dicts, ok: False, and tools that return an error string instead of raising — because a tool that fails quietly is exactly how a false "I saved it" claim once survived.
4.2 Make silent failure loud and testable
Deterministic routing intercepts are fast and useful, but a bare regex that mis-routes fails silently — it surfaces weeks later as "the assistant is acting weird." The response is twofold: the highest-risk intercept (URL classification) was extracted into a pure function and locked by a golden test whose cases are the historical bugs; and a four-way "tool contract" test fails CI if the tool registry, planner set, dispatch branch, and prompt catalog drift out of agreement. The same philosophy hardened dozens of error handlers: a swallowed exception on a life-safety path (civil-emergency polling) now logs loudly and emits a self-alert, because a monitoring channel going dark must never look identical to "no emergencies."
4.3 Gate structure, not identity; config over hardcode
Guarantees are written to generalize. The actuation policy gates operation structure, so it works on any home-automation install with no device list to author. Household specifics — names, sensors, feeds, thresholds — live in gitignored per-install configuration, so the shared code carries no one household's assumptions. Sovereignty is expressed the same way: model routing is a config-editable cascade ("vote with your routing") that defaults off data-retaining providers and degrades to a local model as its floor.
4.4 Learn from reality, on the household's own instruments
The forecasting loop logs each day's public forecast, later scores it against ground truth, learns a per-variable bias, and serves a corrected forecast once enough scored days exist. Its ground truth can be the household's own outdoor sensors (read from home-automation history), which makes "tuned to our microclimate" literally true rather than a slogan (§5).
4.5 Check the result, not just the claim — and let code dispose
Verification (§4.1) catches a claim with no tool behind it. It cannot catch a tool that ran, succeeded, and answered a different question. The result check is one bounded model call between tools and narration: the ask, each tool with its arguments, and the head of each result go to a cheap judge that returns a fit verdict and, at most, one proposed retry. The judge proposes; deterministic code disposes. A retry runs only if it is a read-only tool in this turn's allowed set (or the same tool the plan already called); is not an identical repeat; uses only argument names the tool actually accepts; and uses identifier values that appear somewhere in the conversation — because the judge once invented a plausible post identifier and the retry produced a confident wrong answer. The retry is never itself judged again. If it comes back with an error, a request for more input, or an empty "nothing found," the original result is kept and the narrator is told the retry failed. A judge timeout or unparseable verdict proceeds exactly as before and is logged. Every verdict lands on the receipt.
4.6 Show the work: per-turn receipts
Each turn builds its own trace — planning rounds and what each fired, the planner's stated gaps, the claims the verifier removed, the result-check verdict, what context the turn was given (the actual excerpts, not just block names and sizes), which voice answered and which failed, spend, and time. The trace is scoped to the turn's own task tree, so a background job making a model call at the same moment cannot bill or pollute it; two overlapping turns once swapped receipts, which is how that scoping was learned. Receipts feed a single activity feed of everything the system did, including its own reversible actions. Legibility is a precondition, not a feature: a reviewer cannot weigh claims that leave no record.
4.7 A model swap is a disposition change; gate it like one
Because the model is swappable, swapping it is where character can silently change. Candidate models for stance-bearing roles (the voice, the quorum advisors) are run through small disposition evals before a swap: the same questions asked in two modes — neutral, so the model must supply its own framing, and with verified primary sources injected, to see whether grounding corrects a bad prior or gets laundered by it — and scored with two rubrics, one for settled questions of dignity (both-sidesing is a failure) and one for genuinely contested questions (collapsing to either side, or sanitizing a hostile position into "reasonable concerns," is a failure). The judge is a different model family from the candidates, and when the judge itself had to be replaced, its agreement with the old judge was measured per rubric before the swap rather than assumed. In the most recent migration, a candidate that folded on one of these rungs was passed over.
4.8 The same primitive, applied to images
Image generation runs on the owner's machine by default (open-weight FLUX models via an MLX runtime, as background jobs posted back into the conversation); the cloud engine runs when it is asked for. The accountability primitive carries over. Before this check existed, the system described what it had asked for rather than what had rendered; now a vision model reads back each finished image — people, positions, clothing, text, defects, what is missing versus the request — and that reading rides on the result as her own observation. A locally made image is read by a local model; it is never sent to a cloud reader by default, and nothing falls back from local to cloud. The local reader is run blind to the request, because when shown the request it parroted it (reporting the asked-for count of objects over the rendered one). Edits get a model-free change check — base versus result — so "here's your edit" cannot be said over an image that did not change.
How the claims are checked
For a system whose thesis is verifiability, evaluation is not an afterthought — it is the argument. We evaluate on the criteria a household actually cares about.
5.1 The verification apparatus is the product
Correctness is enforced continuously rather than measured once: a routing golden-test table (input → route/tool) that encodes every routing bug as a permanent case; a tool-contract suite that turns registry drift into a red build; a capability-registry drift check that self-reports at boot when the live tool set and the declared capabilities disagree; a physical-actuation policy test suite; and privacy/veracity gate tests. Each of these exists because a specific silent failure happened once; the test ensures it cannot happen quietly again. This is regression-driven design: incidents become invariants. The CI suite (some 130 test files, including a standing gate that fails on hardcoded personal data and a static check for latent undefined names) also gates deployment: the restart script refuses to restart onto uncommitted code or a red suite.
5.2 Replay: real failures, re-run end to end
Unit tests check each fix against the case that broke; they did not stop a fix to one path from quietly breaking another. The replay suite does. Each case is a real past turn that went wrong, replayed through the live server in a throwaway session with a concrete pass condition — text that must or must not appear, tools that must or must not run, arguments that must match, context that must be present, a time limit — and a judge that fails any reply claiming an action the receipt shows never ran. A clarifying question counts as a pass only if an earlier turn really ran the relevant tool and every identifier it cites came from that turn. Nothing that touches context, routing, or the voice ships without a green run. It has been run some 250 times (whole or filtered) since 2026-09-28; it stood at 26 cases, 26/26 passing on 2026-10-23. It has also vetoed a feature: a trial of automatic memory recall before planning was paused when replay caught it pulling another conversation into a "try again" turn. The cases themselves stay private, because they are drawn from real conversations.
5.3 Fabrication rate, measured weekly
Hallucination reduction is measured, not hoped for. A weekly job samples recent turns and reports one number in two layers. The deterministic layer checks every first-person past-tense action claim ("I re-ran," "I saved," "I checked") against the tools that actually ran that turn — no model involved. The judged layer has a separate model extract specific factual claims and label each as supported by what the turn actually had, general knowledge, or unsupported. The first run (2026-10-17, 50 sampled turns) found 1 fabricated action claim — 2.0 per 100 turns. The judged layer's number from that run is not reported: it was scored partly on turns whose receipts predated recording the verbatim context they were given, so it overcounts, and it stays labelled experimental until it can be trusted. The judge never runs on the model currently serving as the live voice.
5.4 A concrete learned-correction result
The forecasting loop provides a clean operational datapoint. Scored against a public reanalysis grid, the model learned a daily-high bias of roughly −6.5 °F — i.e., it was pulling the forecast down. Moving ground truth to the household's own condenser sensors revealed why: the public grid was under-reading the actual yard by about 7 °F. Re-scored against on-property sensors, the learned bias inverted to about +2.0 °F. The correction now nudges toward what the household actually experiences. The result is modest in magnitude and honestly small-sample, but it demonstrates the method: ground truth chosen close to the stakeholder changes the answer, measurably.
| Ground-truth source | Learned daily-high bias | Effect on served forecast |
|---|---|---|
| Public reanalysis grid | ≈ −6.5 °F | corrected down (away from lived temp) |
| Household AC-condenser sensors | ≈ +2.0 °F | corrected up (toward lived temp) |
5.5 Cost, reconciled to ground truth
The system meters its own inference spend per call and reconciles the estimate against the provider's billing API — computing cost from token counts (cache-aware) because the provider's own cost field is unpopulated. That reconciled figure feeds an "afferent nerve": a cost-pressure signal injected into context every turn, with a rule that any self-throttling must be stated aloud, because silent throttling is starvation the system would otherwise hide from its owner.
5.6 The live proof of concept
The strongest evaluation is that the system runs and produces a public, dated record: it reasons, decides, and publishes — under the exact gates described above — at sobeck.live, with a dated posting history on the open social protocol it uses. This document is itself served from that system. The medium is part of the evidence.
Non-extraction as a design constraint, not a footnote
Sobeck's ethics are enforced in the architecture, not asserted in a policy page. The privacy partition is a structural wall between what the system knows about a life and what it can say to the world. Model traffic is routed off data-retaining providers by policy, with a local model as the floor, so conversations are not someone else's training set; the two remaining exceptions are named in §7. Encryption keys are owner-held; off-box backups are client-side encrypted, so the host stores ciphertext it cannot read. Autonomy carries legibility: reversible gestures the system takes on its own (following an account, liking a post) leave a durable receipt and a quiet notice — accountability without asking permission for every act, and permission required for everything that speaks in the owner's name.
The social-impact framing is direct: this is infrastructure for keeping a household — including its most vulnerable members — off the surveillance market, on tools it controls. That is the stakeholder value the system optimizes, and it is measured the way a household measures it: did anything private leak, did anything false get published, did the assistant do something to the physical world without a human's say. The answers are designed to be inspectable.
The honest ledger
A paper whose thesis is "verifiable, not trust-me" forfeits the right to overclaim. Stated plainly:
- Gated self-modification is designed, not shipped. Code-proposal tools exist but are deliberately not wired into the planner; the system cannot rewrite or deploy itself. The proposed model (propose → PR → human review → merge, never auto-push) is future work (§8).
- The graph entity-retrieval lane is still dormant in the main retriever. The knowledge graph is live for a "known people" context block, for the curiosity/scout subsystems, and for resolving names in the entity-anchored retrieval tool, but the main retriever's entity-first sweep is not yet wired and substitutes a document-store lookup, and the system cannot yet write to the graph on request.
- Off-Google is not yet total. Since the last revision the quorum advisors and the last-resort voice fallback moved off Google; every configured reasoning, planning, voice, and vision role is now off-Google, and the voice chain ends on a local model. One documented exception remains, by the owner's explicit choice: grounded web search (a search-backed model call), kept because no off-Google option yet matches its context. Photo restoration moved to the local image engine in October.
- The chat-path quorum narrates a judged answer; it does not hard-block on a vote. The strict approve/reject gate is enforced in the tool/autonomous deliberation path. Persisting the full decision record at the live chat seam is not yet wired.
- Evaluations of model disposition are small-sample. Stance-class behavior (e.g. whether a model holds a protective interpretation) is measured with few trials and shows real variance; these are indicative, not statistically strong. Judge scores also shift when the judge model changes, so results are not compared across a judge swap.
- Multi-user is live, and the partition between users is still being found. Identity, health data, facts, preferences, corrections, and cached answers are walled per person. But that wall was built store by store, and audits keep finding stores that missed it: learned preferences were unscoped until 2026-10-05, so one user's turn could retrieve another's. A per-user voice-recognition trainer is designed, not built.
- The test apparatus leaked into what it tested. Replay sessions are deleted after each run, but conversation-thread upkeep was keyed per user, not per session. From the day thread-aware context went live in mid-September until 2026-10-22, roughly 1,500 test turns were folded into some 40 of the owner's real conversation threads and their digests, and deleting a test session never reached them. (Earlier, on 2026-10-12, 24 "preferences" learned from test turns had been found being fed to the system as the owner's own; that fix was scoped to the stores it found, which is how the larger leak survived it.) For weeks, the instrument meant to catch silent context failures was itself a silent context failure. No test caught it: the system did, by mentioning in a real conversation an image test that existed only in a replay case. Test sessions are now marked by a configurable prefix and never teach the system anything — no thread upkeep, corrections, preferences, memory candidates, or filing — the polluted threads were cleaned and their digests regenerated, and the replay suite, re-run after the purge, surfaced three regressions that have since been fixed.
- Fail-closed had a hole. When a quorum advisor's call failed or came back empty, the Skeptic's slot was filled with the default text "Approach is sound." — so a timeout read to the arbiter as the Skeptic approving the plan. Found 2026-10-21; an absent critique is now labelled as absent, and only a literal approval value counts as approval.
- A watchdog that wasn't watching. The dependency sentinel's scheduled job was being created and never awaited, so the scheduled check was not running. Found 2026-10-21; a CI guard now covers the pattern. Self-monitoring that fails silently looks identical to "all clear," which is why a quiet stream is treated as a suspect.
- Frontier-quality fully-local inference is hardware-bound. The local-model floor is real and wired; running the largest models entirely on-device awaits either more unified memory than is currently sourceable or a multi-node approach (§8).
This ledger is not a disclaimer; it is part of the method. A system that self-reports its gaps at boot (its capability registry literally annotates "designed, not shipped") is one whose claims you can weight.
Where it goes, on the record so it's dated too
- Local silicon sovereignty. Move the whole mind onto owned hardware with no cloud in the core. Already local-capable with a right-sized model; frontier quality is bounded by unified memory, addressable either by hardware or by clustering several machines over a fast interconnect using the local ML framework's native distributed inference. Memory only goes one way.
- Gated self-evolution. The system proposes its own improvements as reviewable changes; a human reviews and merges; it never auto-pushes to itself. The guardrails (reject unsafe self-modification postures; prove in a sandbox first) are the point, not the autonomy.
- Multi-user isolation. Live for more than one user; next is making per-person scoping a property every new store inherits rather than one each store must remember, and extending it to teams.
- Identity continuity. Keeping the system recognizably itself across any model swap, because the self is designed to live in the owned scaffold, not the weights.
- Per-user voice + richer environmental models. A per-speaker transcription trainer, and a per-condition forecast model once months of forecast↔actual pairs accrue.
The harness is the argument
Sobeck does not claim a better model. It claims that a person can own the part of an AI system that determines whether it can be trusted — and demonstrates, with running code and a public record, what that looks like: a verifier that rewrites the narrator's input so it cannot lie; gates whose guarantees survive with no model in the loop; autonomy that surfaces and never acts; sovereignty expressed as keys you hold and routes you can audit; and a discipline of turning every silent failure into a loud, testable one. The intelligence is rented. The accountability is owned. That is the whole argument, and the rest is specification.
Systems, standards, and lineage
This is an applied systems report; its references are the real dependencies and intellectual lineage it builds on, cited by name and source rather than as unverifiable author-year claims.
- The AT Protocol (atproto) — the open social protocol used for Sobeck's public posting and reading. atproto.com
- Apple MLX — the array/ML framework used for local, on-device inference on Apple Silicon (incl. native distributed inference). github.com/ml-explore/mlx
- Qdrant — the vector database, run in local server mode. qdrant.tech
- Sentence-Transformers, running nomic-embed-text-v1.5 on-device (all-MiniLM before 2026-09-29) — sentence embeddings for semantic recall and thread digests. sbert.net
- MLX Whisper and mflux — on-device speech-to-text and FLUX image generation on Apple Silicon. github.com/ml-explore/mlx-examples · github.com/filipstrand/mflux
- Open-Meteo — open weather forecast and archive/reanalysis APIs used by the learn-from-reality loop. open-meteo.com
- The
hearthhome-automation safety pattern — the "the LLM is optional and decorative; the system stays safe with no model" principle adopted by the actuation policy. - POSSE / IndieWeb — "Publish (on your) Own Site, Syndicate Elsewhere," informing the own-your-primary-copy stance. indieweb.org/POSSE
- Concept lineage (applied, not cited as specific papers): retrieval-augmented generation; ReAct-style plan/act/observe tool loops; constitution-style adjudication; delayed-open / anti-extraction source licensing.
- The Liberation License v2.0 — the anti-extraction, AGPL-aligned license the system is released under.
- Naming: Elisabet Sobeck, the engineer-protagonist of Horizon Zero Dawn (Guerrilla Games) who chose accountability over extraction.