LexStrike

LexStrike stress-tests your contracts by role-playing the people most likely to exploit them. Hostile AI agents attack each clause, a Defender argues back, then you fix and re-verify.

Comment

Inspiration

Every freelancer I know has signed at least one contract they shouldn't have. Not because they're careless but because a lawyer costs more than the gig is worth, and you can't see how a clause gets weaponized until it already has been. I looked at the existing AI contract tools and they're all built for the same audience: corporate legal teams running a compliance check against a playbook. None of them show a freelancer how the person on the other side of the table would actually use their own contract against them. That gap is what lead to LexStrike.

What it does

You paste in a contract, agreement, NDA, whatever and tell LexStrike what kind of document it is and which side you're on, and a set of AI agents goes after it, each one playing a specific hostile counterparty. The Non-Paying Client looks for every way to avoid paying you. The Scope Creeper looks for every way to demand more work than you agreed to. The IP Thief looks for a way to claim what you made before you get paid for it. Each attack is written out in plain English, pinned to the exact clause it exploits. Then a Defender agent pushes back on its own team, arguing whether the risk is real or already covered somewhere else in the document so you get an actual back-and-forth instead of a one-sided list of scary bullet points. If a clause turns out to be vulnerable, you can rewrite it, and the same attacker comes back and tries again on your new version, so you actually know if the fix held. The repaired contract can be downloaded at the end.

How I built it

LexStrike is a three-screen Next.js app, built entirely in Codex, streaming everything live over Server-Sent Events. I described the adversarial agent structure to Codex: attack, then debate, then fix, then re-verify — and it wrote the SSE handling, ran the agents in parallel, built the clause heatmap, the debate feed, and the export to .txt/.docx/.pdf. I owned the product decisions: giving each agent a specific hostile persona instead of one generic "reviewer," and forcing every fix through a re-attack, because a fix nobody checked isn't a fix. The document itself never leaves the browser — only the extracted text goes to the server, and the API key stays server-side the whole time.

Challenges I ran into

Keeping the live heatmap in sync with the debate feed over SSE turned out to be the hard part. The clause being discussed has to drive both panes at once without one lagging or racing ahead of the other, and a finding can only show up on the heatmap after the Defender has actually responded to it, not the moment the attacker raises it. Getting GPT-5.6 to produce clause-specific dialogue instead of generic legal summary took a lot of prompt rewriting before it stopped sounding like a disclaimer.

Accomplishments I'm proud of

A live, multi-agent adversarial engine with a real fix-and-verify loop and working document export, built solo in a week. Four full demo scenarios: freelance, employment, NDA, lease ; each scenario runs a real attack, a real defense, and a real rebuttal.

What I learned

That the useful thing an AI can do with a contract isn't summarize it. It's argue against you, from the other side's chair, until you see what you missed.

What's next for LexStrike

Getting the eval set reviewed by an actual attorney across a few jurisdictions, supporting more document types, and exporting with the original formatting preserved instead of flattening it to plain text.

Built With

Share this project:

Updates