Contract AI: Vendor Claims vs Reality

Most "AI contract review" tools do not review contracts. They run NLP-based search over clause text and surface matches. That is useful — but it is not what the marketing implies. Understanding the gap between vendor claims and what the technology actually does saves you from buying a search tool at review-tool prices.

What vendors say vs what the product does

A typical vendor pitch: "Our AI reviews your contracts in seconds and flags risky clauses." What actually happens: the system runs keyword or embedding-based search across your document, matches clause fragments against a library of known patterns, and returns results ranked by similarity score. That is information retrieval, not legal analysis.

True contract review requires understanding context, jurisdiction, counterparty history, and business intent. No commercial tool does that autonomously in 2026. The ones that come closest pair LLM summarization with human review loops — and they cost $500+/mo for a reason.

Where NLP search genuinely helps

Search-based clause verification is a real, practical workflow. You have 200 vendor agreements. You need to know which ones contain auto-renewal clauses, liability caps under $1M, or non-standard IP assignment language. Running structured search across those documents in seconds instead of hours is a legitimate time-saver.

The honest framing: this is contract search, not contract review. Search finds the clauses. A human (or a carefully prompted LLM with human oversight) reviews them.

Building a clause verification pipeline

A practical approach uses search to gather context, then an LLM to summarize findings for human review. The search step needs to be reliable — not hallucinated.

import requests

def search_clause_context(clause_text: str) -> dict:
    """Search for legal precedent and standard language
    around a specific clause type."""
    resp = requests.post(
        "https://api.scavio.dev/api/v1/search",
        headers={"x-api-key": "YOUR_API_KEY"},
        json={
            "query": f"standard contract clause: {clause_text}",
            "platform": "google",
            "num_results": 5
        }
    )
    return resp.json()

# Example: check if an indemnification clause is standard
results = search_clause_context(
    "unlimited indemnification obligation supplier"
)
for r in results.get("results", []):
    print(f"Source: {r['url']}")
    print(f"Snippet: {r['snippet']}")
    print("---")

The vendor claim checklist

Before buying any "AI contract review" tool, ask these questions:

1. Does it flag clauses or analyze them? Flagging is search. Analysis requires reasoning about the clause in context of the full agreement and applicable law.
2. What happens when it misses something? If the answer is "the human reviewer catches it," then it is an assistant, not a reviewer.
3. Can it handle non-English contracts? Many tools trained primarily on US/UK English legal corpora fail on civil law jurisdictions entirely.
4. What is the false positive rate? A tool that flags 80% of clauses as "risky" is not useful — it is noise.

A realistic contract workflow in 2026

The stack that works today: document ingestion (parse PDF to text), clause extraction (NLP/regex), search-based verification (check flagged clauses against known standards), LLM summarization (generate a plain-English brief), and human sign-off. Each step is auditable. No step claims to replace a lawyer.

# Step 2: verify flagged clause against current standards
flagged_clause = "Supplier shall indemnify without limitation"

verification = requests.post(
    "https://api.scavio.dev/api/v1/search",
    headers={"x-api-key": "YOUR_API_KEY"},
    json={
        "query": (
            "is unlimited indemnification standard "
            "in SaaS vendor agreements 2026"
        ),
        "platform": "google",
        "num_results": 3
    }
)

# Feed verified search results to LLM for summary
# The LLM summarizes — the human decides
sources = verification.json().get("results", [])
context = "\n".join(s["snippet"] for s in sources)
print(f"Verification context:\n{context}")

Honest tradeoffs

Search-based clause verification at $0.005/query (Scavio) or $0.0006/req (DataForSEO) is cheap enough to run at scale. But it does not replace legal expertise. It replaces the manual step of Ctrl+F across 200 PDFs. That is the real value — and it is significant. Just do not let a vendor charge you $2,000/mo for what is fundamentally a search product with a legal skin.