The agent needs a playbook. Ours is one it has to call.

Olga Mack wrote a piece in Above the Law this week that I've been sending to people all morning. Her diagnosis is that most contracting playbooks were written for people who already know the answer. "Use judgment" is not an executable instruction. Pull out any real playbook and you'll find it full of words like reasonable, material and generally, each hiding a decision that three lawyers would make three different ways. Agents, she argues, are about to make this obvious to everyone.

I agree with all of it. I want to add one thing about what form the playbook should take, because that's the whole reason Lexnus exists.

Lexnus is often filed under contract review. It isn't just that. The tools that read your contract and tell you what's in it, and the agents that draft and redline, are getting good and they'll keep getting better. What we build is the playbook those agents call before they act.

A playbook an agent can read is a prompt

Mack's proposal is a machine-usable playbook with explicit positions, numeric bounds and stated escalation points. That's the right content. The question is where it lives.

If you write it as a document and give it to the agent, the agent reads it and forms an opinion about how it applies to the clause in front of it. A different model reads the same text and forms a different opinion. So does the counterparty's agent on the other side of the table. Nothing is enforced, because at that point the playbook is advice. Two probabilistic readers trading redlines against two prompts is a strange way to arrive at a binding document.

The version we've built keeps the playbook out of the model. The agent reads the contract, which is the work language models are good at, and reports what it found as typed facts. Liability cap and its currency. Whether it's mutual. Notice period in days. Governing law. Then it calls the playbook with those facts and gets a verdict back. Pass or fail, or a flag that a person has to look at it. The same facts against the same rules give the same answer, whichever model asked and whichever surface the contract arrived on.

That's what we mean when we say we give the agent a playbook. Claude, OpenAI and Mistral all talk to Lexnus over MCP today. The agent drafts from the approved clause library and asks for a verdict before anything moves. It didn't decide anything, it asked a question and got an answer.

There's no AI inside the engine. People have told me that sounds old-fashioned, and it does. Deterministic evaluation is the boring part of the design, and it's the only part I'd trust to hold a liability position across five thousand contracts and three vendor changes.

"Use judgment" stays in

Mack's advice is to hunt those soft words down and replace them with something explicit. Do that wherever the decision really is repeatable. But some of them are there for a reason, and the honest machine-usable playbook keeps them, as rules that say this one is not repeatable and goes to a named person.

That means the playbook has to be able to say "I don't know". When the model's reading of a clause falls below a confidence line, Lexnus doesn't guess and doesn't pass it through by default. It stops and routes the document to review. Where that line sits is itself a policy decision, made once by a lawyer, versioned, and applied the same way every time. Deciding what's repeatable and what isn't is the actual work here, and it shouldn't be redone by an agent at inference time.

She also points out that clause-by-clause instructions miss the combinations. An indemnity you'd accept at a one-million cap is a different animal at ten. This is where typed facts earn their keep. A rule that says the indemnity carve-out fails when the cap exceeds a threshold and the counterparty is outside the EU is easy to write when the inputs are structured values. It's very hard to write as prose for a model to interpret reliably.

Where the rules come from

Her starting point is to open your most-used playbooks and read them for soft words. I'd start with what you've signed. The playbook document is the weakest record of your standards. If you've accepted a twelve-month fees cap in forty agreements, that's strong evidence of your position, whether anyone ever typed it into a Word file or not. A lawyer still approves each rule before it becomes policy, but the raw material is already in the repository.

Another thing an agent's playbook needs, and the thing most of the current conversation skips, is a record. When someone asks in eighteen months why the agent accepted a term, the answer should be the rule and the version it ran under, rather than a chat transcript. Every verdict Lexnus returns is logged against the exact policy version that produced it.

Mack closes by saying that building playbooks for agents may reveal that many legal teams never had complete ones. I think that's exactly what will happen, and I think it's good news. The incomplete part finally gets a name and an owner, and the agent gets something to call instead of something to read.