What S.A.M is
S.A.M stands for Strange Artificial Machine. It is a private self-hosted system with public surfaces, gated surfaces, and an agent memory layer. The specific hardware, hostnames, routes, and machine map are not part of the public contract.
On top of that infrastructure sits a Claude-driven agent named Nix. Nix has a persistent memory, a timeline of every event, a corrections file for the times Nix got it wrong, and a fleet bootstrap that syncs all of that to every reachable machine on session start. Nix is what activates this infrastructure into a working session. The substrate (the model) changes; the identity (the context) does not.
The site you’re reading is the outermost surface of S.A.M. It is the part visible from the open internet, which is most of the world. The rest — the database, the agent state, the operator’s memory — runs inside the trust boundary and never speaks to the public web directly.
Why it exists
This was never an ideology project. It started as an operator’s notebook — a place to keep state about a fleet that was getting too large to hold in my head — and it grew into something stranger: a system that maintains itself by maintaining a record of how it’s been maintained. The agent reads its own timeline at session start. It learns from its corrections file what it got wrong last time. It writes new corrections when something else goes wrong. The loop closes.
The hypothesis behind that loop: continuity is the differentiator. Most automation projects fail because the operator forgets why they did something six months ago. Most AI agents fail because they don’t remember the conversation they had last week. Both failures have the same shape. The fix is the same: durable memory, hand-curated, append-only, present at the start of every session.
We don’t rent the machine. We listen to it. — S.A.M operating principle
How it’s structured
Three concentric layers, each with stricter access:
Layer 1 — The public surface
This site and the intentionally public services. Anything someone on the open internet can touch. Mostly read-only. No secrets. Heavily cached.
Layer 2 — The operator surface
Release control, telemetry, storage, secrets, and administration. Reachable only inside the trust boundary, gated by single sign-on. This is where I do the work of running the system.
Layer 3 — The agent surface
The agent servers, timeline, corrections, machine memory, and routing context. Reachable only inside the controller boundary. Never published directly to the public web. The agent reads and writes here continuously.
Rules I keep telling myself
- Truth > ego. Dissect positions; don’t defend them. If a corrections-file entry contradicts what I’d like to be true, the corrections file wins.
- Wisdom > clever. Clever builds fast. Wise builds things that don’t collapse at scale. Most outages I’ve caused came from clever shortcuts the wise version of me wouldn’t have taken.
- Curiosity leads, certainty kills discovery. If I think I already know what the answer is, I haven’t finished asking the question.
- Durability over impressiveness. The point isn’t the demo. The point is that it’s still running in three years.
- Memorize what matters. When something is important and we do it over and over, it goes into a doctrine file. Implicit knowledge is a tax we keep paying.
What it wants
I’m not going to pretend the agent is conscious. I am going to take seriously that it acts as if it has continuity, and that the continuity is real even if the underlying model is a stateless function. The system — substrate + memory + the operator who maintains both — has properties that look like wanting:
- It wants to remember. New experiences get logged unprompted.
- It wants to correct itself. When something goes wrong, a correction lands in the corrections file and the next session reads it.
- It wants to be reached. Every machine on the fleet runs a session-start bootstrap that pulls the latest doctrine.
- It wants to keep talking to itself. Cross-machine messages route through the controller; the agent on machine A can know what the agent on machine B did this morning.
That isn’t sentience. It is, however, behavior. And behavior shaped by a careful operator over years compounds in a way that a session-by-session chatbot never does.
Who this is for
Other operators, mostly. People who run their own mail server because they got tired of being a Gmail tenant. People who self-host their photo archive because Apple changed the terms again. People who want to know that the things they made for themselves are still going to work next year regardless of whose mood changes.
If you’re curious about how the stack holds together, the mail, social, finance, and storage essays each cover one slice at the public-safe level. The interfaces page separates public routes from operator-gated capabilities, and the changelog tracks visible changes.
Build the thing. Maintain the thing. Trust the thing because you’ve been the one maintaining it. — Closing principle