This documents the system that does the work: small single-purpose agents, composed into fixed pipelines, checked by a separate gate, handed off through written contracts.
Not a product tour. This is how the machine is built and why it is built this way, the decision behind each part and the alternative it rejected. The short version lives on How it works; the run lives on See it work. This page is the depth underneath both. Built and run independently by Jaden Van, a paralegal, in daily use inside a California criminal-defense practice in Beverly Hills, where it supported a federal trial. The client firm's own attorney reviews and signs every deliverable.
One shape, four decisions. The architecture reads on a single line.
A single general-purpose assistant cannot be checked, because there is no fixed spec for what it was supposed to do. This system is built the other way: the work is broken into small jobs, run in a fixed order, and checked by something that did not do the work. Here is the whole shape, then the four decisions that produced it.
Small single-responsibility agents, not one big agent
Each agent does one narrow, checkable job, and nothing else. It reads discovery, or it checks citations, or it profiles a judge. A worker with one job can be verified in isolation and reused in parts. Small jobs are checkable jobs.
Fixed pipelines, not improvised chains
A pipeline is a set sequence. In law the same task needs to run the same way every time, and you need to know where it is when it fails. The order is where the judgment lives: facts are pinned before prose, strategy is approved before argument, citations are checked before the pour.
A separate verification gate, not self-checking
Between the draft and the desk sits a set of reviewers that never saw the draft written, reading the source documents the drafters never opened. A fresh-context reviewer is the only thing that catches a confident, finished, wrong document. Section 05 shows the day it did.
Written contracts between agents, not shared memory
Agents hand off through standard documents, the same artifacts a human team hands each other. An agent has no memory of the conversation, so the handoff has to carry everything: the task, what done means, and how to hand the result back. Section 04 is that story.
The agents, grouped by what they do.
Every example output shown in these cards is invented: names, charges, dates and docket numbers are built for illustration and match no real person or matter. The behaviour is the real behaviour.
Eight finished jobs, each a fixed run of those agents that ends in the gate.
The drafting pipeline halts for the attorney's theory. But the halt sits after research, not before.
A drafting pipeline never writes a sentence of argument before the theory of the case is approved, a hard stop. The placement is the interesting part. The halt comes after research, samples, and the adversary forecast have run, so what the attorney approves is a real, research-grounded strategy, not the model's opening guess. There are two separate gates: the cheap up-front choice, motion type and scope, at triage, and the substantive one, the theory, once there is something real to approve.
It works inside the systems the practice already lives in.
The one constraint that shaped everything: an agent cannot stop to ask a clarifying question.
A system of independent agents has the same problem a team of people has. A worker with no memory of the conversation cannot pick up another's work without a written contract telling it what to do, what done means, and how to hand the result back. The difference from a human team is the one that made the documentation strict: an agent cannot pause and ask, so the document has to be complete, or the handoff fails.
Every worker hands back the same typed slip. No worker is allowed to pretend.
A pipeline dispatches an agent with a self-contained brief and gets back one typed envelope, the same shape for every agent, the agent's own result riding inside an opaque data field. The form forces an honest answer: it worked, it did not have enough to go on, or it errored.
Status is outcome, not quality. There is no fourth option where a worker guesses and reports success. A failure reports as a failure, rather than arriving as a confident answer. That one choice is the safety spine.
The reviewers never saw it written. And they read the source the drafters never did.
The terminal check every high-stakes output passes before a person sees it. The agents that wrote the draft can all agree with each other and all be wrong together, so a separate gate of reviewers checks the finished draft, each with no memory of how it was written, each applying one rubric. Six automated reviewers run on a filing, two on an internal draft.
A felony filing, marked finished and ready, carried four defects no internal check would surface, because an internal check only compares the draft to itself.
Each reviewer runs with its write tools removed.
A reviewer is dispatched with no drafting memory and cannot mutate anything, it can read and report only. A reviewer that could quietly fix things would hide the exact defect you wanted surfaced. Read-only is what makes the check honest. A known defect blocks delivery; it is never downgraded to clean-up-later.
Done is a condition a machine can check, not a feeling that it looks right.
The redaction test is one instance of the rule: re-render at 300 DPI, OCR the pixels, search for every protected name, and if any returns, it failed and rebuilds. Every definition of done in the system is a machine-checkable condition, which is what lets the gate be strict without a human in the middle of every step.
A failure on a live matter is fixed at the class, not the instance, and locked as a test that runs on every release.
When something goes wrong on a real case, it is abstracted to a fault class, fixed at the source, and logged with a validation target that proves the fix worked and a rollback that undoes it. An append-only log holds shipped changes; a lifecycle queue holds pending ones. Nothing is silent, nothing is lost. The failure this replaced was improvement notes dying in a chat that ended before anyone acted.
A template hardcoded a court venue instead of reading config. Invisible for months, because every matter was in that county.
Then a new-county matter mis-captioned. It was caught by the verifier, not the generator, fixed as a class by parameterizing every venue, and validated two ways: the original re-rendered byte-identical, the new county came out correct. Rollback was five minutes. That single incident is verification catching what generation missed, a class-not-instance fix, and a traceable, reversible change, all at once. The design spec for this loop even has a before-and-after: it first read single-writer, no concurrency concerns, until a real lost-update bug forced an optimistic-locking rewrite. The documentation evolves in response to incidents.
An enforced rule
The correction becomes a rule an independent reviewer checks on every future draft. Not a note someone has to remember. A gate that runs.
A frozen regression case
The exact failure is locked into a test set that re-runs, so it cannot come back quietly. If it ever reappears, the test fails loudly.
A reusable sample
The corrected work becomes the template the next draft is mined from, so the improvement spreads to new matters instead of staying on one.
Under the agents sits the layer that keeps the system legible to itself.
The bench and the pipelines are the visible machine. Underneath is the part an enterprise cares about: how the system stays lean, routes to the right source, and enforces its own governance with tooling instead of discipline.
One file, loaded every turn, deliberately lean
The kernel holds only what must fire every turn: identity, hard constraints, the always-on directives, the routing table. Everything else lives in topic docs loaded on demand. An always-loaded file that grows unbounded buries its own most important rules, so keeping it lean keeps the safety-critical ones at highest attention. That is progressive disclosure as a safety choice, not a tidiness one.
A source-routing table, including the sources that do not answer
Each need maps to the one source that answers it, and explicitly to the ones that do not. The wrong source is a silent detour that wastes a session, so the playbook names the right door and closes the wrong ones.
Governance as tooling, not as discipline
A deterministic validator runs at install and on any change that touches the registry: name collisions, missing dependencies, status drift, trigger overlap, oversize metadata. It converts everyone remembers to update the registry from a convention into an enforced check that must pass. This is the clearest artifact of building governance in rather than relying on people.
The improvement loop pointed at itself
A read-only self-diagnostic runs on a cadence over the kernel, the queues, the logs, and the registry. It produces a dashboard of signals with thresholds and a ranked list of findings, so drift is surfaced before it becomes a defect.
- A draft is never uploaded to check its citations. The text is read on the machine, and only the list of citations leaves it for verification.
- Files are never used to train any model. The tools run under terms that forbid training on the data.
- It wires into the systems already in use. The work happens in the firm's email, drive, and case files by connector, not by copying everything into a separate product.
- Redaction verifies its own output. Every client copy is re-rendered, OCR'd, and searched for any protected name that survived.
Watch it run, read what it produces, or point it at your practice.
See it work →
The discovery-audit pipeline on a built case, step by step, including the Brady contradiction it catches and the two source documents you can inspect.
the outputRead a real deliverable →
An actual motion the firm filed, pulled from the public record and redacted to initials, with a note beside each part naming the judgment behind it.
the offerRun it on one matter →
Where the pitch lives. Pick one real matter, and it runs on your case, with your own attorney reviewing and signing the result.