Self-describing all the way down

People ask me two questions about AI and Pulse, and they ask them as if they’re unrelated. How much of this do you build with AI? And what does the AI inside actually do for the agent?

They’re the same question. The answer to both is a single architectural discipline, applied twice — once to the codebase, once to the product. It’s worth writing down, because it’s the part that doesn’t show up in a demo.

The move: make the system describe itself

The failure mode of “AI-powered” anything is the model guessing. It guesses because it’s working next to the system instead of inside it — reading a screenshot, pattern-matching on a prompt, filling gaps with plausible fiction. That’s the sidebar-bolted-onto-a-legacy-stack problem, and no amount of model quality fixes it, because the model was never given the ground truth to begin with.

So we don’t start with the model. We start by making the system legible to it. Everything of consequence carries a machine-readable account of what it is, what it’s for, and the rules that govern it. The system publishes the truth about itself, and the model operates against that truth rather than against a hunch. Grounding isn’t a feature we added; it’s the precondition we build everything else on.

That one decision is what makes both halves of this note work.

Building Pulse

Pulse is built by two founders, a small distributed team, and a fleet of coding agents, all working the same repository. That only holds together because the repository tells the agents — and every person — how it’s meant to be built.

There’s a single canonical rulebook every agent reads before it writes a line, so a human contributor and four different coding agents all operate from the same constitution instead of four private guesses. The architecture isn’t defended by code review alone; it’s enforced mechanically — the standards that matter most, the ones that protect personal data and keep each agency’s records walled off from every other’s, are checked by tests that fail the build if they’re violated. An agent can’t quietly skip the compliance-shaped parts, because the parts that matter most are the parts the machine refuses to let slide.

Two things fall out of that, and they’re the ones I’d underline:

• We build the way we ask the agent to build. Features are specified before they’re written, the spec and the plan live next to the code they produced, and the reference material the agents read is generated from the system rather than hand-maintained — so it can’t drift out of date and quietly start lying to the next agent. The documentation is downstream of the truth, not a parallel story about it.
• Blame stays truthful. Every agent-authored change says so. We’re not interested in pretending the team is bigger than it is, or that a human wrote what a model wrote. The honesty is the point — it’s the same honesty we owe a regulated customer.

The depth of Pulse — the number of real modules doing real casework — is not a claim about how hard we worked. It’s the visible output of a build system that lets two founders, a small distributed team, and a set of agents move like a much larger shop without losing the plot. The discipline is what buys the speed. Take the discipline away and the speed becomes debt.

Inside Pulse, for the agent

Now the same move, pointed at the customer.

Pulse records the facts of a case — who the client is, what’s been lodged, what’s expiring, what the file actually contains — as structured, queryable truth. So when an agent asks a plain-language question — what’s blocking this family’s 482?, where do I set this up?, what should I do next on this file? — the answer is assembled from that agency’s own files and the current state of the rules, not improvised. Grounded, with its sources attached, so you can check the working. When it points you somewhere, it can take you there. When it thinks a form should be started, it arrives pre-filled for you to confirm — because the job is to review, not to author from a blank page.

A few things we hold firm on, and won’t move on:

• The human stays on the trigger. The assistant reads widely and proposes freely, but it doesn’t reach in and change your files on its own. Extraction from an uploaded document — a passport, a test result — comes back as a finding a person accepts, edits, or rejects, and every accepted fact remembers where it came from, down to the page. Suggestions are suggestions. The next best action is offered, not executed. In a practice where someone’s registration is on the line, suggested, not dictated is not a UX preference. It’s the safety model.
• Not everything we call intelligence is a model — and we don’t pretend otherwise. Some of the sharpest parts of Pulse are deterministic rules watching for the things that quietly sink cases: an expiry cliff, a mismatch across documents, a case going stale. Those want to be exact and explainable, not probabilistic. Knowing which problems deserve a model and which deserve a rule is most of the craft. Reaching for the model every time is how you get something that’s impressive in a demo and untrustworthy on a Tuesday.
• It learns your practice, not your neighbour’s. The value compounds where the work happens: the more an agency uses Pulse, the better Pulse fits that agency. That fit is the product, more than any single feature.

Why the two halves rhyme

Set them side by side and it’s the same sentence. To build Pulse, we make the codebase describe itself so agents can work on ground truth with a human enforcing the rules. To run Pulse, we make the practice describe itself so the model can answer on ground truth with a human confirming the moves. Self-describing systems, grounded AI, a person on the trigger — all the way down, at both layers.

That’s not an accident, and it’s not a slogan we reverse-engineered. It’s the thesis we’ve been building toward: don’t try to push the frontier — use it well, close to real work, in a profession we know from the inside, and let an industry keep its own judgment instead of handing it to a few models to absorb. A learning loop you own only works if the system underneath it is honest about what it is. So we made honesty the architecture.

The model will keep getting better on its own schedule. Our job is to keep the ground true underneath it — in the code we ship, and in the file the agent is looking at right now.