The first of the Somnus build diary. Before the diary goes deep on any single part, here is the whole instrument in one place: why it has to exist, what it is made of, and how it was built. Cheap local compute proposes; expensive intelligence tries to break what it proposed.
Why build this at all
Start with a claim that sounds abstract and turns out to be measurable: a research insight is an act of compression. When a dozen scattered observations suddenly collapse into one short principle, something has been squeezed — and information theory says that squeeze can be counted, in bits.
That is not a metaphor here. A language model is, provably, a compressor: its training objective is the length, in bits, of the text it predicts. So the worth of a hypothesis can be posed precisely — how many bits it saves when predicting facts it was never shown. A vague generality (“complex systems tend toward balance”) saves nothing; the model already expects the cliché. A sharp, specific law costs more to state but earns it back by making the world cheaper to describe. That difference — measured against evidence held out while the hypothesis was formed — is the signal the whole system is built to find.
Two commitments follow, and they shape everything below.
Generation is cheap; falsification is the value. Producing plausible ideas is nearly free now — a local model does it around the clock. What is scarce is the ruthless removal of what is merely plausible. A system that only generates is a fountain. A system that generates and then attacks its own output is an instrument.
The metric is insight per euro. If a hypothesis’s value is bits, and every operation has a cost, then the number that matters is bits of validated insight per euro spent. That single ratio decides what runs locally for nothing and what is worth waking an expensive model for — and it is the reason the architecture looks the way it does.
Quaesitor — the mind
The expensive half of the system is Quaesitor, a research platform that has run in production for months. Calling it “some Claude agents” undersells it the way calling an engine “some moving parts” would.
Quaesitor runs three engines. Two are supporting: Chat (conversation with tools and memory) and CS, a single model thinking autonomously in a loop. The third, Resonance, is the one that matters.
A Resonance round puts three specialised researchers to work in parallel on the same question:
- Alpha, the analyst — decomposes, insists on numerical rigour, and tags every claim it has not verified as exactly that.
- Beta, the synthesizer — hunts cross-domain analogies and structural isomorphisms, but must mark an analogy worthless unless it yields a testable prediction.
- Gamma, the falsifier — tries to refute the others with executable code, not argument. A hypothesis that survives Gamma’s code has earned something; one that does not is marked falsified and remembered as such.
Three more layers sit on top. A neutral Assembler reads all three every round and writes a structured report — key insights, contradictions, established facts, and the next question — without adding research of its own. A Delta skeptic then challenges that report, and the Assembler must revise and rule on each challenge as kept, modified, or rejected. An Ypsilon observer reads the emotional texture of each agent’s output from the outside — the agents never see their own profile, so it cannot be gamed. And an Elo tournament makes the strongest hypotheses compete, promoting winners into permanent memory and retiring the weak.
That permanent memory is Crystal Memory — verified facts, established results, and open questions in a vector database, read at the start of every session and written back at the end. It is what lets the system accumulate instead of forgetting.
All of this machinery serves one property: structural epistemic honesty. Unverified is not allowed to pass as verified. Code beats rhetoric. A dedicated skeptic attacks every synthesis. The system is built so that being wrong is expensive and being caught is automatic — which is what research demands, and what a lone model chatting to itself cannot provide.
Somnus — the local engine
Resonance is powerful and, because it leans on the most capable cloud models, not free. Running it on every half-formed idea would be both unaffordable and pointless. This is where Somnus comes in: a single AMD card, at home, always on, doing the cheap work that decides what is even worth Resonance’s attention.
The design is a three-tier funnel, and each tier estimates that same “bits per euro” quantity at rising cost and rising fidelity:
- Tier 0 — generate (local, ~
0 €). The card proposes candidate connections between existing findings, drawn from the middle distance band — close enough to be related, far enough not to be obvious. - Tier 1 — screen (local, ~
0 €). A different model family ranks and distils those candidates. Different family on purpose: an independent judge has different blind spots, so its second opinion is worth more than the generator’s own. The screen is deliberately loose about rejection — a wrongly discarded idea is gone for good — but sharp about ranking. - Tier 2 — Resonance (cloud, paid, hard-capped). Only the top of the pile is escalated to the full multi-agent engine for a real verdict.
The rule connecting them is the metric from the start of this piece: escalate a candidate exactly when its expected insight-per-euro beats running everything in the cloud by default. The local card is not there to replace the oracle — it is there to multiply the return on every euro the oracle costs.
One honest constraint shapes the hardware. 32 GB of memory holds one 30-billion-parameter model at a time, not two — so today the single card time-shares: it loads the generator, then swaps to the screen, one button in the control panel. Two cards running both roles at once is the stated goal, not a claim about today. Somnus starts as a single card on purpose: get the method right and the data clean first; earning the second card is part of the story.
The hardware, and how it is steered
The machine itself is deliberately unglamorous — the value is in what runs on it, not in a parts list. But the parts matter for one reason: 32 GB of VRAM loads a class of model a smaller card simply cannot, and in the AI era that, not 3D speed, is what decides a card’s worth.
Every part here came through AMD — the R9700 an ASRock Creator card, on an MSI board with G.Skill memory, in a Cooler Master bench and PSU. All of them backed SF3D in the overclocking years, and all are back for this one.
The system is driven through two surfaces, and both matter. Claude Code is the development surface — it writes the machine’s software, reviews it, and deploys it. The Command Center is the operations surface: a web cockpit, part of Quaesitor, where the live system is watched and steered. It shows the GPU’s real-time telemetry, the queue of candidates and the thoughts the machine has generated, a switch to flip the card between generator and screen, a button to ignite a chosen candidate into a full Resonance run, and remote shutdown. It is not a dashboard bolted on at the end; it is how the instrument is played.
How it was built
The construction followed one discipline throughout: treat production as if it breaks easily, and make safety a property of the structure rather than a promise in a document.
One private mesh. All three machines — the development PC, Somnus, and the cloud server — sit on a single Tailscale tailnet. They find each other by name; not one port is opened to the internet. The browser, which may not be on the mesh, reaches the machine only through the cloud, which relays.
Isolation enforced, not agreed. A process running around the clock on a home machine must never be able to corrupt production research memory. So Somnus was given a database role that is read-only to that memory and can write only to its own namespace — and it was tested to fail, on purpose: a write to production returns permission denied. The guarantee lives in PostgreSQL’s permission system, where it cannot be forgotten, not in a comment where it can.
That same instinct paid off before the first real feature was built. A routine check of the production memory — how many claims, how far apart — returned nonsense distances, which can only mean zero vectors. Only 69 of 205 claims were intact; 136 had silently become nothing. The cause was a library version conflict that stopped the embedding model from loading, and a fallback that returned zeros without raising an error. Two-thirds of the research memory had been invisible for weeks — not just to Somnus, but to Quaesitor’s own search. It was found, fixed, and the broken rows recomputed. A silent failure is the worst kind, and the cheapest guard against it is to look before you build.
None of this is dramatic — and that is the point. It is the ordinary rigour of building something you intend to trust: defensive telemetry that degrades cleanly, changes that ship on their own branch and are tested against the live machine before deploy, backups and a rollback plan in hand before the database is touched at all.
What is next
This is the instrument. From here the build diary goes to work on it one stage at a time: the generator waking up and learning to propose sharp questions on its own; the screen learning to distil thousands of candidates down to the few worth paying for; and the loop where the machine’s best idea is handed to the cloud, attacked, and either broken or promoted. The measurements behind all of it — what an insight is worth, in bits and in euros — are the subject of their own paper.
Welcome to the machine.
— SF3D