Legal was supposed to be either the easiest or the hardest sell for generative AI, depending on who you asked in 2023. Easy: legal work is disproportionately reading and writing, exactly what LLMs do. Hard: legal has near-zero tolerance for fabrication, and every hallucinated citation is a career-ending mistake.
Three years in, both camps were half right. The naive deployments — a lawyer asking a chatbot to write a brief — produced the disasters that made headlines. The scoped deployments, where the LLM is doing a specific piece of a well-defined workflow with a lawyer in the loop, are quietly doing enormous amounts of work in enormous numbers of firms and in-house teams.
The contract drafting and summarization agent generalized fastest. It's a good fit for the technology, a good fit for the workflow, and the risk model — draft, don't decide — is one legal teams know how to govern.
What the use case actually is
A contract agent is a scoped LLM system with three core responsibilities. Drafting: producing a first-pass contract or clause based on a playbook, template, and brief. Review: reading a counterparty's redlines against the playbook and identifying what's in-policy, what's a negotiation point, and what's a hard problem. Summarization: taking an executed contract (or a stack in due diligence) and producing a plain-language summary of obligations, term, termination triggers, and risk-shifting provisions.
Thomson Reuters' framing of AI-assisted drafting for CoCounsel captures the operating model: the agent produces a draft, an attorney reviews and edits, and the value is compressing drafting from hours to minutes while the attorney remains the accountable author. Bloomberg Law's analysis of AI-written contracts makes the same point from the risk side: drafting and review as machine work, decision-making and sign-off as human work.
What the agent actually does
In a real deployment inside a corporate legal team, the loop looks like this. Sales sends over a customer-requested MSA redline. The contract agent reads it, compares against the playbook, and produces a memo: here are the clauses that match the standard, here are the changes that fall inside pre-approved negotiation ranges, here are the two provisions that need actual attorney attention.
The attorney reads the memo, spends time on the two flagged provisions, and lets the routine changes through. The three-hour redline review becomes a thirty-minute one. On the drafting side, the agent generates a first-pass response to the redline — clauses accepted, clauses countered, reasoning noted — that the attorney reviews and sends.
For summarization, the value shows up in diligence and ongoing obligation management. MyCase's overview of AI for legal contracts frames this for smaller firms: the agent reads an executed contract and produces a structured summary — parties, term, obligations, termination, notice, indemnity, liability caps — that used to require a paralegal afternoon and now takes minutes. In an M&A stack, the agent processes hundreds of target-company contracts into a structured summary the deal team can actually search.
The technical pattern that ended up winning is decomposed, not single-pass. Width.ai's contract summarization writeup documents the approach most production systems converged on: split the contract into legally meaningful chunks, extract structured fields per chunk, then synthesize a natural-language summary from the extraction. Single-shot summarization on a 100-page contract hallucinates. Structured decomposition doesn't.
Why it beats the pre-copilot workflow
The pre-copilot workflow was mostly manual reading and writing, augmented by document assembly for the templated parts and Word for the rest. The bottleneck was expensive attorney and paralegal time — associate hours at $400-800 depending on the firm.
The contract agent doesn't replace those humans. It replaces the specific hours they were spending on work that didn't require legal judgment. A junior associate reviewing a stack of NDAs against a playbook was producing consistency-checking value and nothing else. The agent produces the same output in minutes.
The measurable effects are two. Cycle-time compression: contracts that took two weeks now take three days, because internal review cycles compressed. Capacity reallocation: the associate who was on the NDA stack is on the deal that actually needs judgment.
The pattern that doesn't work — that keeps producing the disasters — is treating LLM output as final. Every category of legal work has an audit trail, and every hallucinated citation eventually gets caught. The teams that survived built the workflow assuming the model will occasionally lie, and designed the review step to catch it.
Where this is being built
The vendor landscape in 2026 is dense. At the top, Thomson Reuters CoCounsel, Harvey (dominant in Big Law), and Ironclad (contract lifecycle native) are the platforms most enterprise legal teams evaluate first. Below them, a strong middle tier — Spellbook, Robin AI, Lexion, Evisort — competes on specific workflow depth and on the ease of dropping into an existing document workflow rather than replacing it.
The deployment split that matters is between the platform model, where the agent is the front door of a whole CLM system, and the copilot model, where it's a Word or Google Docs plugin on top of whatever CLM the team already has. Teams with a serious CLM already deployed tend to buy the copilot layer; teams starting from scratch tend to buy the platform.
The technical differentiator is retrieval and grounding. A model producing language that matches the team's specific playbook, cites internal precedent, and knows the difference between the customer-facing MSA and the vendor-side one — that's where the integration investment shows up. The vendors that took retrieval-augmented generation seriously early ended up ahead. Big Law bought Harvey and CoCounsel to compress associate hours; in-house teams bought Ironclad-style CLM platforms to compress cycle time on their own contracts. The workflow and value story differ in each direction.
How to evaluate a solution
The demo is the least useful thing to look at. Every vendor can show a smooth review of a clean NDA. The tests that matter are unpleasant.
Ask how the model handles a citation. If it fabricates a case name in a drafted argument, that's disqualifying. If it grounds every citation to a real document from the retrieval corpus, that's the baseline. There is no middle answer a legal team should accept.
Ask what the false-summary rate is. The vendor should be able to tell you what percentage of the time the summary contradicts the underlying contract. If they don't measure this, they don't know, and you'll find out the expensive way.
Ask what happens to the input documents. Contracts contain confidential business terms and privileged communication. The data-handling answer needs to include tenant isolation, non-training guarantees, and specific retention policies — contractual, not marketing language.
Ask about playbook integration and audit trails. A contract agent that requires a support ticket to update the playbook will stay out of date forever. Every clause drafted, every redline classified, every summary produced should be logged in a form the general counsel can review after the fact. If the vendor treats audit as an afterthought, that's the story.
The legal teams getting real value from contract agents in 2026 are treating them as leverage for existing legal discipline, not as an autonomous drafting system. The ones treating them as autonomous are producing very confident, very wrong contracts and finding out about it in litigation. The pattern works only because the lawyer stays in the loop. That's the design, not a limitation.