This Isn't a Portfolio. It's a Control Plane.

Most personal sites are a résumé with better typography. This one runs itself. Every morning it pulls live rates data, writes a brief, decides — in code, not vibes — whether that brief is good enough to publish, and logs exactly why it made the call. If the data is stale or thin, it doesn't ship a worse brief. It holds, and it records that it held.

I didn't build that to be clever. I built it because I build AI for regulated workflows — places where "the model said so" is not an answer you're allowed to give a regulator, an auditor, or a court — and I wanted a working answer to the question everyone in regulated AI is actually asking: how do you let a language model touch a serious workflow without it becoming the thing you can't explain?

The site is the answer, in miniature.

The trap everyone walks into

The obvious way to make an AI agent "explainable" is to ask it to explain itself. Have it narrate its reasoning, log the narration, show it to the auditor. This is comforting and completely wrong. A language model's "here's my reasoning" is not the cause of its output — it's a story generated after the fact, about as reliable as asking someone to explain a decision they made by reflex. It reads well. It is not evidence.

So I stopped trying to make the model explainable. Instead I made sure the model is never on the decision that has to be explained.

Demote the model to draftsman

Every autonomous action on this site is split into layers, and the language model only ever touches the one that doesn't need to be defended in front of anyone. The deterministic spine — context, the rules, the ledger — runs down the center. The model hangs off the side.

  deterministic spine            bounded model
  ──────────────────             ─────────────
   Context ─┐
   Rules ···┤ checked by          ┌──────────┐
            │                      │  model   │
          ┌─▼────┐    draft        │ draftsman│
          │ GATE │ ◄────────────── └──────────┘
          └──┬───┘  schema · sources · confidence floor
       pass  │  fail
        ┌────┴─────┐
        ▼          ▼
     Ledger      abstain
    (receipt)  (no row, no publish)

It generates, it doesn't ground. When the daily brief is composed, the model writes the prose — the headline, the one-liners, the "what it means for your shop." It does not write the numbers. The numbers are placed by code, pulled from a validated dataset, slotted into a schema. The model is physically incapable of typing a wrong rate into the artifact, because it never types rates at all. Then a guardrail re-reads the prose and rejects any decimal that isn't within a hair of a real reading. It can't sneak a number in through the side door either.

It doesn't decide, and it doesn't grade itself. Whether the brief publishes is a pure function — schema valid, every figure sourced, data fresh, confidence above a floor. That confidence is computed from how complete and how fresh the inputs are. The model is never asked "how sure are you?", because a model's opinion of its own certainty is worthless. Below the floor, the system abstains. It would rather say nothing than say something weak.

Nothing happens without a receipt. Every action writes one immutable row to a ledger — inputs, sources, the decision, the reason, the computed confidence, and the version of the governing rules in force when it ran. If it can't write that row, it aborts. No row, no publish. The log isn't a record of what happened; it's a precondition for anything happening at all.

The autonomy is fenced. The site reorders its own homepage from real signals — but it can only permute a fixed set of modules. It can't invent one, hide them all, or touch the content. The weekly rant you're reading? An agent can draft; only I approve. The agents can propose anything; they can only do a short, typed, reversible list of things.

Why a string-prepended "constitution" is more than a gimmick

There's a document — a literal Constitution — that governs every agent. Articles, clauses, the works. It's prepended to every prompt, yes, but that's the least important part. The important part is that it's versioned, and the version is stamped onto every row in the ledger. Which means the log is replayable against the rules that were actually in force, not the rules as they exist today. When the rules change, the human-readable document and the machine-readable clauses move together, by policy. That's the difference between an audit trail and an audit trail that survives contact with a lawyer.

It keeps its own score

The brief makes exactly one falsifiable observation a day — a Lending Conditions Index, a 0-to-100 read of the origination climate, computed deterministically from three rates. Not a prediction. Not advice. Just a reading of the numbers in force. Days later, a separate job re-measures the same thing from fresh data and logs — publicly, win or lose — how that reading aged. No model grading its own homework. Just arithmetic, in the open.

You don't have to take my word for any of this. Today's brief shows the gauge live; the ledger keeps the running scorecard. A publication that keeps its own score is a different kind of thing than one that doesn't.

So what is this, really

It's a neuro-symbolic control plane wearing a personal site as a disguise. The model is a bounded component — a generator bolted to the side of a deterministic system of record. The context, the rules, and the ledger are the system; the model is the draftsman. The honest framing: I didn't make a language model explainable. I built an architecture where it doesn't need to be, because it's been moved off the decision, and the decision is made by something you can read.

And that's the whole point, because the place this pattern matters isn't a personal site. It's regulated work — lending, healthcare, insurance — anywhere an agent that makes a decision has to produce the specific, true reason it made it, and "the model said so" ends your company. A loan denial needs a real adverse-action reason. A care recommendation needs a defensible basis. A claim decision has to survive an appeal. Everyone in those rooms now has the language model. Almost nobody has wrapped it in something an examiner would sign.

That's the thing worth building. This site is just where I proved it works.

If you're working on auditable AI in any regulated domain and this resonates, the architecture is documented in the open, and I'm always up for the argument. — Ryan