AI agents for contract lifecycle management: where the agent drafts, and where a lawyer still signs

In 2023, two attorneys filed a brief in Mata v. Avianca citing six cases that did not exist — ChatGPT had invented them, complete with fake quotations, and the lawyers filed without checking. The judge sanctioned them. Three years later, the database that tracks these incidents — maintained to a strict bar, only decisions where a court found reliance on fabricated material — is well past a thousand cases and climbing steeply through 2026. That’s the backdrop against which every “AI for contracts” pitch now lands, and it’s why the interesting question isn’t whether an agent can help with contract lifecycle management. It’s exactly where you let it act and where a human still has to sign.

Because the upside is genuinely real. Contract review is slow, expensive, high-volume, pattern-heavy work — the kind of task where a grounded model earns its keep. The whole CLM market re-pointed itself at agents through 2026: Gartner’s Magic Quadrant names Sirion, Docusign, Agiloft, and Ironclad as leaders, and every one of them shipped an agent in front of the workflow. This post is the architecture that makes that safe on a Salesforce estate: where the value actually concentrates, the copilot-to-agent shift and what it changes, the grounding-and-gates pattern that keeps it auditable, and the honest limits that decide whether you should let an agent near a contract at all.

Where the value actually concentrates

The instinct is to automate the whole lifecycle — intake, drafting, redlining, approval, signature, renewal — end to end. Resist it. The pain isn’t spread evenly, and the risk profile of each stage is wildly different. Map the lifecycle by how reversible the agent’s output is and the design falls out on its own.

• Intake and triage — low risk, high friction. A request lands as an email or a Slack message: “we need an NDA with this vendor.” Someone classifies it, pulls the counterparty, picks a template, routes it. This is structured drudgery, it’s the birthplace of off-process contracts, and an agent handles it well. Ironclad reported its intake automation cut average submission time roughly in half in early results — a vendor figure, but the shape of the win is real and it’s the safest place to start.
• Drafting from templates — low-to-moderate risk. Generating a first draft from a pre-approved template and record data is mature, and it’s bounded: the agent assembles from clauses a lawyer already blessed, it doesn’t invent language.
• Review, redlining, and clause extraction — high value, high risk. This is where the money is and where the danger lives. Extracting the indemnity cap, comparing a counterparty’s paper against your playbook, flagging the missing limitation-of-liability — enormously useful, and exactly the surface where a model can hallucinate a clause that isn’t there or misread one that is.
• Approval routing — deterministic, not agentic. Who signs off at what threshold is a workflow decision, not a reasoning one. It belongs in Flow approval orchestration, not in a model’s judgment.
• Obligation and renewal tracking — moderate risk, compounding value. After signature, someone has to track auto-renewal windows, notice deadlines, and obligations. Agents are good at watching for the trigger and drafting the response; the decision to renew or renegotiate stays human.

The takeaway that governs everything downstream: start where output is cheap to reverse (intake, draft) and put a hard human gate on everything that isn’t (final redlines, approval, signature). This is the same reversibility-and-blast-radius calculus we apply to any agent action worth gating.

Copilot vs. agent: the distinction that changes the architecture

Through spring 2026 the CLM conversation shifted from copilot to agent, and the difference is not marketing. A copilot waits for you to ask — it suggests a redline, answers a question about a clause, drafts on request. An agent maintains state across the workflow: it knows where a contract sits, what has to happen next to advance it, and which system or person to engage — and it acts on a trigger without a human prompting each step. When a counterparty returns a redlined MSA, an agentic system can re-run it against the playbook, update the risk summary, and route the exceptions to legal, unprompted.

That autonomy is the whole point and the whole hazard. It’s the difference we drew in agentic AI vs. generative AI: generation produces content on request; agency takes action toward a goal. State persistence is what makes an agent useful across a multi-week negotiation — and it’s what makes an unsupervised one dangerous, because it will happily advance a contract on a conclusion it got wrong.

The honest test before you buy the agentic tier: if your team runs fifty contracts a quarter, a well-configured template-and-approval setup beats a half-adopted agent platform every time. Agentic CLM earns its complexity at volume, not by default.

The architecture: grounded reasoning over a deterministic spine

The single most important design decision in a contract agent is the same one that governs every agent that touches something consequential: separate the reasoning from the committing, and ground the reasoning in the actual document — never the model’s memory of it.

Ground on the contract text, not the model’s training. The failure mode in Mata v. Avianca was an ungrounded model asked to recall law it never had. The fix is retrieval: the agent answers only from the specific document in front of it. On Salesforce, contract PDFs, MSAs, SOWs, and SLAs live as unstructured data an Agentforce Data Library turns into a RAG-grounded retriever — Salesforce auto-provisions the search index and the agent answers from retrieved chunks rather than free-associating. Where you need tighter filtering, Intelligent Context does a better job of scoping retrieval, though it’s constrained today — PDFs and images, with real size limits — so confirm it fits your document profile before you commit to it. Either way, grounding on Data 360 requires it enabled; there’s no RAG-over-your-contracts without the data foundation underneath.

Extract to structured fields; let deterministic code decide. An LLM is excellent at reading “the aggregate liability cap is 12 months of fees” out of dense prose and terrible at being the system of record for whether that’s within policy. So the agent extracts entities and clauses into structured fields — Salesforce Contracts has native AI-based extraction for exactly this — and a deterministic layer evaluates them. The reasoning proposes; the platform decides, the same way every time:

extract_clauses(document)      → {liability_cap, indemnity, term, auto_renew, governing_law, ...}
compare_to_playbook(clauses)   → deviations flagged against the approved clause library
check_thresholds(deviations)   → which deviations exceed the auto-approve band
route_for_review(contract)     → deterministic approval orchestration to the right lawyer
create_obligations(clauses)    → tracked renewal/notice dates, logged

Wrap actions and gate the consequential ones. Each of those steps is a governed action — a custom Apex action or a wrapped API, permissioned and logged — not a free-form model call. Approval routing runs through Flow orchestration, which became a standard feature in 2026 and gives you multi-stage, multi-stakeholder review (legal → finance → an external partner) with interactive screen-flow steps. The agent drafts and proposes; the human gate is where a person with a bar number actually reads the final language before it goes back to the counterparty.

That boundary — grounded retrieval in, structured extraction through, deterministic evaluation and a human gate out — is what turns a demo into something a general counsel will sign off on.

Where Salesforce actually fits

If your quote-to-cash already runs on Salesforce, the CLM pieces are closer than teams expect. Salesforce Contracts, part of Revenue Cloud, is the native product: template design, a clause library, obligation management, DocuSign integration, and AI-based extraction of entities and clauses into contract records. It sits naturally alongside Agentforce Revenue Management — the same quote-to-cash spine, with the contract as the artifact the deal produces. On the AppExchange, Conga CLM is built natively on the platform, while Docusign CLM integrates in from outside; the native-vs-integrated split matters for how cleanly an agent can reach the contract data.

Agentforce is the reasoning layer over that spine. You ground it on the contract repository through a Data Library, wire extraction and routing as custom actions, and keep the model out of the commit path. What you should not do is assume a fully autonomous “detect the renewal, check compliance, generate the offer, send it” agent ships in the box — that pattern appears in a lot of 2026 marketing, but treat any specific autonomous capability as something to verify against current Salesforce release notes and, more likely, something you compose from grounded actions and a human gate rather than flip on. The safe, shippable version keeps a person in the loop wherever the contract’s terms actually change.

The limits that decide whether to ship

This is the part the vendor demo skips, and on a legal workflow it’s the part that matters most.

Hallucination doesn’t stop at purpose-built tools. A Stanford RegLab study found that even dedicated legal-research AI hallucinated on a meaningful share of queries — Lexis+ AI and Westlaw’s AI research tool both produced incorrect answers at rates well above what “hallucination-free” marketing implied. Grounding on the actual contract text dramatically narrows the surface, but it does not eliminate the risk that a model misreads a clause or asserts one that isn’t present. Every extraction an agent makes on a contract that matters needs a verification path, not blind trust.

Confidentiality and privilege are live risks. Feeding privileged or confidential contract content into a consumer-grade public model can constitute disclosure to a third party and jeopardize privilege — a real concern courts have engaged with. This is a decisive argument for keeping contract AI inside a governed boundary: the Einstein Trust Layer’s zero-retention and masking posture exists precisely so prompts and documents aren’t training someone else’s model. It doesn’t make the workflow risk-free, but “we ran it through a governed enterprise agent” is a very different sentence from “someone pasted the MSA into a chatbot.”

The regulatory picture is narrower than the headlines — get it right. Under the EU AI Act, the “administration of justice” high-risk category in Annex III targets AI used by or for a judicial authority in researching and applying the law — courts, not ordinary commercial contract review. Private-sector CLM generally isn’t high-risk on that basis alone, unless it spills into other listed uses like HR or credit decisions. Don’t let a vendor scare you into a compliance program you don’t need — but don’t wave the risk away either, because professional-conduct rules bite regardless of the Act. ABA Formal Opinion 512 applies existing duties to generative AI directly: competence (understand the tool’s limits), confidentiality (informed client consent before inputting confidences — boilerplate in an engagement letter isn’t enough), and candor. The lawyer stays responsible for the output; the tool never absorbs that.

The through-line: these aren’t reasons not to build. They’re the reasons the human gate isn’t optional. An agent that drafts, extracts, and routes — with a lawyer reading every material change before it leaves — captures most of the speed and almost none of the liability. Skip the gate and you’ve automated your way to a sanctions order.

What to actually do

The teams getting real value from CLM agents in 2026 aren’t the ones who handed the contract to the model. They’re the ones who scoped it hard: agents on intake and first drafts, grounded retrieval for review, deterministic extraction into structured fields, and an unmovable human gate on final terms, approval, and signature. That’s not timidity — it’s the design that lets you move fast on the ninety percent that’s routine while a lawyer’s attention lands where it’s actually needed.

If you already run Salesforce, you have most of the spine: Salesforce Contracts for the record and the clause library, a Data Library to ground an agent on your repository, and Flow orchestration for the approval gate. Start with intake, prove the extraction against a corpus you can check, and only widen the agent’s reach as its accuracy earns it — the same discipline that separates the agent projects that survive production from the ones that get cancelled. The prize is a legal team that reviews exceptions instead of everything. The way you lose it is by trusting a confident summary of a clause nobody verified.

Understanding the basics

Can an AI agent replace a lawyer for contract review?

No — and designing as if it can is how firms end up sanctioned. A grounded agent is excellent at the mechanical layer: extracting terms, comparing a contract against a playbook, flagging deviations, drafting first passes, and tracking obligations. But models still misread and occasionally fabricate clauses even when purpose-built for legal work, and professional-conduct rules keep the lawyer responsible for the output. The workable pattern is agent-assisted review with a human gate on every material change, not autonomous review.

How do you keep a contract agent from hallucinating clauses?

Ground it on the actual document instead of the model’s memory. On Salesforce that means a RAG-backed retriever — an Agentforce Data Library or Intelligent Context over your contract repository — so the agent answers only from retrieved text, plus structured extraction into fields a deterministic layer evaluates against your clause library. Grounding narrows the risk sharply but doesn’t eliminate it, so every consequential extraction needs a verification path and a human review gate before the terms change.

Does Salesforce have a native CLM product?

Yes — Salesforce Contracts, part of Revenue Cloud, provides template design, a clause library, obligation management, DocuSign integration, and AI-based clause and entity extraction. Conga CLM is a long-standing native AppExchange option, and Docusign CLM integrates from outside the platform. Agentforce is the reasoning layer you add on top, grounded on the contract data and wired to deterministic actions and approval orchestration.

---

Trying to work out where an agent can safely touch your contract process — and where the human gate has to stand — before it goes anywhere near a live agreement? Talk to us. Designing agents that move fast on the routine and stop cold at the consequential is exactly the work we do.