The Note That Knows What's Signed

In the flagship piece I said the whole practice runs on a folder Claude reads and writes. Its companion post is about the corner of that folder that holds legal knowledge: what the law says. This one is about a different corner that answers a narrower, more dangerous question: on this deal, what did we actually agree to, and is it still true?

It started as a mistake waiting to happen.

What structured memory is

Most of my practice runs on notes. Client files, matter logs, a short “current state” block at the top of each matter so I can pick it back up cold. Prose notes are good at a lot of things. They have one weakness I kept bumping into: they forget where they came from.

Structured memory is the fix, and it’s less exotic than it sounds. Instead of writing a fact in a sentence, you write it as a record with fields: the claim, where it came from, whether it’s still current, how sure you are. A sentence and a record can carry the same fact. Only the record carries whether you should still trust it.

That distinction is the whole post.

What I had, and the limit I kept hitting

A matter note says the commission is ten percent. Is that from the signed agreement, or from a draft that got renegotiated three rounds later? The sentence reads the same either way. Six months on, nobody can tell without re-reading the whole folder.

That gap is where real mistakes live. The worst version is a term from a superseded draft getting treated as if it were binding: advice built on a number that stopped being true two redlines ago.

I already had a rule for exactly this. In the vendor review that kicked off this whole project, three separate errors traced to the same cause, and the rule that came out of it was one line: a fact about a governing document comes from the document, never from a summary or a memory of it. The trouble is that a rule in your head does not enforce itself. Prose notes will still flatten a draft term and a signed term into identical-looking sentences. I wanted the rule built into the memory, not just written on top of it.

The idea I borrowed, and the part I threw away

The push came from Christian Brown, who writes about persistent memory for AI agents and is building a full swarm memory function into his own platform. The pitch: instead of re-reading a whole document set every session, the agents extract the facts once into a structured store and carry that forward, so the system gets smarter across sessions instead of starting cold each time.

What Christian is building is the full version, with the persistence layer and the orchestration wired together. I wanted something lighter for a solo practice, and my setup let me get away with it. The infrastructure didn’t interest me; the output format did. Underneath the machinery was one discipline: capture each fact as a typed record with its source and a confidence level, and track whether it’s still current. In a system that’s already files plus an agent that follows procedures, you can have that discipline with nothing but a file.

What I built: a blackboard next to the prose

For a matter, alongside the human-readable notes, there’s now a small structured file. Think of it as the machine-readable twin of the “current state” block. Each material term is one record: the claim in plain words, its source down to the document and section, a status, and a confidence level. Two short lists round it out: open questions the file can’t answer yet, and dated obligations like a renewal window or a payment trigger.

The status field is the point. It’s one of executed, superseded, draft, or proposed. That single field is the difference between a note that remembers a fact and a note that remembers whether the fact is still true.

That’s the entire thing. No database, no server. A file that sits next to the notes, written and read by the same skills the practice already runs to review contracts and manage deadlines.

It earned its keep on the first matter

I built the first one on a closed commercial agreement with a deep negotiation history: more than ten drafts, redlines in both directions, then execution.

Two things surfaced inside an hour. A file on disk that read like the governing agreement turned out, from its own header, to be an early draft. And the matter note’s own summary of the economics disagreed with the signed contract in two places: a commission figure that traced back to a superseded draft, and a payment-timing detail that had simply been written down wrong.

Neither was hiding. Both were sitting in prose that looked authoritative. Forcing each term into a record with a status and a source is what made them visible. That’s the argument for the whole exercise in one example.

How I expect this to change the work

The day-to-day change is that I stop re-reading a folder to trust it.

Before, picking a matter back up meant reading the current-state block and then, if anything important turned on a specific term, going back into the drafts to confirm the term was really the signed one. That re-checking is most of the work the note was supposed to save. Now the status field answers it up front: the signed terms load instantly, and the ones still soft are visibly tagged soft. I can see what’s settled and what isn’t without opening ten drafts to find out.

The second change is that provenance stops being a hope. Every record carries its source, so “where did we get that” is a field, not an archaeology project. And a shaky inference and a rock-solid signed term no longer read the same on the page, because one is tagged low-confidence and the other executed. For a one-lawyer shop with no second set of eyes, that visible difference is worth a lot.

How it keeps improving, and what it isn’t

The capture is built into the contract skills, so in normal work I don’t ask for it. The review skill writes the record; execution promotes the proposed terms to signed and checks them against the actual signed PDF; the dated obligations flow onto a deadline docket; anything I’m waiting on shows up on a stall report. Those are all skills in the same workspace, so they read and write the same file without anything being wired together. If a step gets skipped, the morning standup and the end-of-day checklist are set up to catch it.

Here’s the limit. This is not a background process watching my files. It runs when the skills run, which is daily and at every wrap-up, not the instant a document changes. It doesn’t verify a term for me at the moment I rely on it. It makes the unverified ones visible so I know which to check. And a record tagged executed is only as good as the read that promoted it; the discipline still depends on the skill actually opening the signed PDF, which is why that check is built into execution rather than left to memory. Reliable enough to trust, simple enough to explain, and clear about where it stops.

The takeaway

You don’t need a memory server to give an AI workflow a memory. If your work already lives in files and an agent already does the work, what you need is a small amount of discipline about structure: separate what’s signed from what’s proposed, keep every fact next to its source, and let the skills you already run write it down. Most of the benefit, almost none of the cost.

Its sibling post is about the same instinct applied to legal knowledge instead of deal terms: a wiki that knows what’s still good law. Both come down to the same move: don’t ask yourself to remember the discipline, build it into the memory. The rule was always right. This is what it looks like when the memory enforces it for you.