The workspace that knows what you decided.

It's where your work lives. It catches you up when you sit down, keeps itself in order while you work, and puts everything away when you leave. Everything else plugs into it.

There is a map of the whole thing: every hook, script, skill and register that runs a session, drawn as a city, sized by real numbers out of the live vault. Open the extended system.

01 · What it is

The system's working state stays as close to yours as it can get. What you've settled outranks what you scratched down. What's in flight stays loaded. This is what I define as congruence.

The judgment lives in your files, never in a model's weights. The files are local, on your machine, and everything you socket in reads from them.

It's an information system, worked through a UI. It looks like a file editor next to a chatbot. The environment underneath connects outward: wire it to your apps and it reads and writes where your business already runs, Amazon, Shopify, Meta.

02 · The registers

Your work has three tenses: past, present, and future.

1. The past: the decisions you've settled, so closed calls stay closed.
2. The present: the principles you work by right now, not last year's.
3. The future: what's in flight and what's blocked.

I call them the cognitive registers.

The registers start almost barren and fill as you work: each close routes what the session settled back into them. Hundreds of sessions in, a framework you fell in love with in March returns as the answer to July's problem, already routed into the tasks you've queued for tomorrow.

They load at the start of every session, and the relevant ones surface mid-work without being asked. I'll start settling something close to a call I made months ago, and the earlier decision arrives before I go looking for it.

> whats the legality of obsidian and claude screenshots on my website

● This is settled — DL-399 (session 531) is exactly this question. Pulling
  the full ruling rather than re-deriving.

  Searched for 1 pattern, read 1 file (ctrl+o to expand)

03 · Many ways in, one place it lands

Argue a decision out with two agents. Hand a subtask to a different model. File a research run. Talk to it from your phone. It all drains to the same place: the files that load at your next startup.

And when a way in grows into software of its own, a CRM, an intel engine, it sockets into the same files as an app. Building those is its own page: systems building.

04 · The human gate

The model generates candidates. You decide which ones are right, and that second step is the whole job. It runs on knowing your clients, your constraints, and what you tried last year that didn't work.

The system is built to make that step cheap. Your settled calls load before you're asked to make them again. Every session the model floats up more candidates, and floats them faster, but each still has to clear the same gate: would you stand behind it? Call it the human gate.

A call that clears the gate becomes a rule the system runs on. Governance: your information carries rules about what outranks what, so the work reasons from what you decided, not whatever it read last.

A codebase has tests. Your knowledge work doesn't, so trust has to come from what you've authored.

1. Search ranks by your trust. A note you marked authoritative outranks a scratch note. Same query, different vault, different answer. Top five 88.8% of the time, top ten 94.4%, measured on my own vault.
2. Conflicts surface before action. New work that contradicts a settled call gets flagged before anything runs with a guess.
3. The stale gets retired. A weekly pass prunes what stopped earning its place.

The difference from most AI memory is direction. Theirs pulls a record out of your work to make the agent faster next time. Mine loads everything you've authored and runs the work inside it.

Better models don't close the gap. A faster generator just means more candidates in front of your gate. It never quietly decides for you, and never teaches itself a new answer behind your back.

840+ sessions of my own calls sit behind that gate.

05 · The silent failure

Nothing about an ungoverned AI setup crashes. It degrades. The context window quietly drops a rule you set in March. A safety check times out under load and the pipeline keeps running without it. A subprocess fails, and the memory layer stores the error message as a fact about your business. All three happened inside my own system, in production, and none of them announced itself. Each surfaced weeks later, on audit, because a silent failure is only ever found on audit.

So the rules that matter here are mechanical. A constraint the model can negotiate away is not a constraint. Writes to the vetted knowledge tier are blocked in code, regardless of what the model decides. Every file change lands in version history the moment it happens, an audit trail nobody has to remember to keep. And the system holds a manifest of which rules are enforced in code and which are only instructions, so it can't quietly claim an enforcement it doesn't have.

None of those gates came from a design document. Each one exists because a specific failure got past me, got measured, and got a mechanism.

06 · What you're paying for

The architecture copies in an afternoon. The judgment takes your sessions.

The honest question: I'm not the only person competent with AI, so what are you actually paying for? The architecture is written up in the essays, and a competent builder can stand the mechanism up. What can't be stood up fresh is section 05: a fresh clone ships the scaffolding and starts collecting its own accidents, while this one arrives with the failures already caught, measured, and paid for. You're buying the scar tissue, then the transfer: set up with you, on your machine, the same system I run this business from.

From there it compounds as yours: you work inside the system and its working state mirrors yours.

07 · Further reading

For the deeper dive into congruence, the idea this page is built on: Congruence: An Architecture for AI-Augmented Knowledge Work.

The rest of the writing, plus the open-source projects: outputs.

The system drawn as a city, one building per part, each one opening onto what actually lives inside it: the extended system.