What happens when the other side sends you an AI-generated contract?

Your legal team has a process for contracts you draft. There's a template, a review step, probably a checklist. Someone signs off before anything goes out the door.

Now think about the contracts that come the other way. A vendor sends you their standard terms. A counterparty's lawyer redlines your draft using an AI tool you've never heard of. A partner's legal team runs their paper through ChatGPT before sending it back. You probably do have a tool that reviews it. The question is whether it applies the same rule, the same way, that governed the contract when you drafted it.

Plenty of contract review tools flag inbound paper against your playbook. What most of them do at that point is make a fresh AI judgement call, "this looks like a deviation," rather than checking a fixed rule. The deterministic check that applied when you sent the contract quietly turns into a probabilistic one the moment it comes back from the other side.

The blind spot in most contract processes

Ask a General Counsel how they make sure outbound contracts meet company policy, and you'll usually get a clear answer: approved templates, a clause library, maybe a CLM with some built-in checks, a fixed threshold that either passes or doesn't. Ask what happens to that same rule once a contract comes in from a counterparty, and the answer usually changes. The rule doesn't disappear. It gets replaced by an AI's judgement call, or by someone manually re-reading the entire contract every time a new version comes in.

That's not a criticism of the review tools. It's how most of them are built: playbook-matching and AI judgement for anything inbound, because the rule itself was never designed to travel in both directions. AI has made it easier than ever for a counterparty to produce a contract that looks clean, reads well, and quietly shifts a liability cap or drops a termination right. Wording matters, and AI is particularly good at making subtle shifts in meaning without much change in the language itself, which is exactly what makes those shifts hard to catch. The volume of paper coming in is only going up. Whether it gets the same fixed check your own drafts get often depends on which tool is doing the reviewing, not on the rule itself.

Why case-by-case judgement doesn't scale

Whether it's a person reading the contract or an AI making a fresh call each time, judgement made case by case produces different answers depending on the instance. A human reviewer catches what they're looking for and misses what they're not, and an AI's judgement can vary from one pass to the next, with nothing fixed to check it against. The result is inconsistency. The same clause might get flagged in one contract and waved through in another, depending on who, or what, reviewed it, on what day, at what time.

That inconsistency is the actual risk. Not one bad contract, but the fact that nobody can say with confidence which of the hundreds you've signed this year actually meet your standards.

What a policy should do, regardless of who wrote the contract

The fix isn't more careful reading. It's applying the same rule the same way, every time, no matter which side of the negotiation the contract came from. If your policy says payment terms can't exceed 60 days, that rule should catch a violation whether it's in a contract you drafted or one the other side sent you. If liability caps below a certain threshold need legal sign-off, that shouldn't depend on whether the clause originated on your side of the table.

This is the principle behind Lexnus: legal writes and approves a rule once, and that same rule governs both the contracts you draft and the ones you receive. No separate process for inbound paper. No relying on whoever happens to be reviewing it that day.

None of this means AI is making the call on a case-by-case basis. AI can read through past contracts and suggest candidate rules, but nothing goes live until legal has reviewed it, approved it, rejected it, or rewritten it. For a deterministic condition, a fixed field comparison like a payment term or a liability threshold, there's no AI involved at all once the rule is approved, it's a straightforward pass or fail. And once legal has signed off, that rule applies the same way no matter which AI tool, Lexnus's own or whatever the customer uses to draft or review, touches the contract. What changes is that the check itself doesn't disappear just because the contract came from someone else's system instead of yours.

If you can't currently answer "how do we make sure inbound contracts meet our standards" with the same confidence as "how do we make sure outbound contracts do," that's worth a closer look.