Which AI is best for lawyers: tasks, risks and checking answers

The question "which AI is best for lawyers" has no single answer: in legal work what matters is not only text quality but also how a model behaves when unsure and where your documents go. Below we cover the tasks where a model really saves time, the main risks (invented references to norms and data leaks), and a method for choosing a model for your own documents, not from someone else's ranking.

A disclaimer: this is not legal advice and not a guarantee of quality. A model helps with draft work, and responsibility for the result stays with the lawyer.

Where AI saves a lawyer time

Models do best on tasks where the answer can be checked against the text you provided:

• Extracting data from a contract. Parties, subject, terms, price, payment procedure, penalty, grounds for termination, jurisdiction.
• A short summary of a long document. What is main in it and what obligations each party has.
• Comparing versions. What changed between versions of a contract and which changes are unfavorable to your client.
• A first check against a checklist. Whether the contract has the required sections and lacks clauses you usually edit. The basics of the approach are in the article contract analysis with AI↗.
• Drafts of letters, claims, templates. As a draft the lawyer rewrites and verifies.
• Structuring case materials. A timeline of events from correspondence, a list of questions for the client.

Where AI is dangerous

• Norms and case law from memory. A model can plausibly name a statute article, a case number or a quote from a ruling that does not exist or says something else. This is the main risk. Check any reference to a norm or case law against an official source or a legal reference system.
• Calculating deadlines and sums. Penalties, interest, counting deadlines: calculate yourself or verify by hand.
• Final conclusions. An opinion for the client must be given by a lawyer.
• Outdated law. A model may not know recent legislative changes.

A practical rule: ask the model to work only from the supplied text and to answer with quotes from it, not from memory. In this mode the risks are noticeably lower, but checking is still needed.

Confidentiality: what you can send

Legal documents often contain information that is the client's secret and personal data. Decide in advance:

1. What may be sent at all. Agree on this with management, the client and the person responsible for data processing. If documents contain personal data, take into account the requirements of the personal data law (152-FZ) and your organization's internal rules.
2. Data retention terms at model providers. We make no statements about the retention policy of specific model providers. Read their terms before sending sensitive documents.
3. Anonymization. Replace names, details and contacts with placeholders before sending and restore them afterwards. This lowers risk and hardly interferes with analyzing the contract's structure.

An example of simple anonymization in Python:

import re

def anonymize(text, names):
    mapping = {}
    for i, name in enumerate(names, 1):
        token = f"[PARTY_{i}]"
        mapping[token] = name
        text = text.replace(name, token)
    text = re.sub(r"[\w.+-]+@[\w-]+\.[\w.-]+", "[EMAIL]", text)
    text = re.sub(r"\+?\d[\d\s()\-]{9,}\d", "[PHONE]", text)
    text = re.sub(r"\b(?:\d{10}|\d{12})\b", "[TAX_ID]", text)
    return text, mapping

def restore(text, mapping):
    for token, name in mapping.items():
        text = text.replace(token, name)
    return text

This is a basis, not ready protection: regular expressions will not find addresses, personal names in different grammatical cases and nonstandard details. Check the result by eye before using it on real documents. If you keep a request log, do not store the document texts in it.

How to build answer verification

Three levels of checking, from simple to labor-intensive.

1. No answers "from memory". The system instruction demands exact quotes and a "not found" marker. An example with the Anthropic SDK:

import os
import anthropic

client = anthropic.Anthropic(base_url="https://api.zukko.pro",
                             api_key=os.environ["ZUKKO_API_KEY"])

SYSTEM = (
    "You are a lawyer's assistant. Work only from the contract text below. "
    "For each condition found, give an exact quote in «...» marks "
    "and the clause number. If a condition is not in the text, write: not found. "
    "Do not cite statutes or case law from memory. "
    "Mark anything that needs legal assessment: needs lawyer review."
)

For the Anthropic SDK the base URL is given without /v1: the client adds the path itself. Request parameters are described in the Messages reference↗.

2. Automatic quote matching. Check that every quote from the answer is really in the source text:

import re

def check_quotes(answer, source):
    norm = lambda s: re.sub(r"\s+", " ", s).strip().lower()
    src = norm(source)
    quotes = re.findall(r"«([^»]+)»", answer)
    return {q: norm(q) in src for q in quotes}

If a quote is not found in the text, it is a signal that the model paraphrased or made it up. Check such places by hand.

3. A human reads the result. Automation cuts off gross errors but does not judge meaning. The lawyer reads the summary with the document open.

Which AI is best for lawyers: a method of choosing

Not a ranking but a test on your documents:

1. Collect 10 anonymized contracts of different types and write down the correct answers in advance (parties, terms, sanctions).
2. Run them through two or three models: for example claude-sonnet-5-5, claude-opus-5-5 and gpt-6.1-sol. All of them accept context up to 1M tokens, enough for long contracts.
3. Count not impressions but numbers: how many conditions were missed, how many quotes were not found in the text (using the function above), how many times the model wrote "not found" where the condition exists, and vice versa.
4. Compare cost on the same documents and pick the cheapest model that passes your threshold.

Reference numbers for orientation: the Artificial Analysis intelligence index is 58 for claude-opus-5-5, 52 for gpt-6.1-sol and 48 for claude-sonnet-5-5. This is a general indicator and does not show the result on contracts specifically, so the test decides.

What it costs

Suppose a 30-page contract is about 20,000 tokens and a summary with quotes takes 1,500 tokens. Formula: input × input price + output × output price. Prices as of 18 October 2026, $ per 1M tokens:

Even a strong model costs pennies per contract, so saving on the model in a legal task is usually unnecessary: the cost of a mistake is higher. Current prices are GET https://api.zukko.pro/v1/models.

AI for lawyers online: how to organize access for a department

• Create a separate key for the legal department in the dashboard↗ and give it a daily and monthly dollar limit. Restrict the allowed model list to those that passed your test. Details are in the key limits reference↗.
• Do not keep the key in shared documents and messengers.
• Keep a log: which documents were processed by which model, without recording the texts themselves.
• Top-ups start from $1: SBP (the payment page fee is 8.5% on top), cryptocurrency or MasterCard cards. There are three ways to pay from Russia: SBP, MasterCard cards and cryptocurrency. Requests can be sent in the OpenAI format (chat completions) or the Anthropic format (Messages).

FAQ

Can I trust references to statute articles in a model's answer?

No, not without checking. This is the most frequent source of errors. Check every norm and case against an official source or a legal reference system.

Is it safe to upload contracts to an AI?

It depends on the document, your agreements with the client and the model provider's terms. Anonymize data, agree what is allowed with management and read the providers' terms. We make no statements about their retention policy.

Which model understands legal Russian best?

There is no universal answer, and we do not claim any model is superior. Compare two or three models on your own anonymized documents using the method above.

Do I need RAG for a base of templates and internal regulations?

If the base is large, yes, and then answers are built from found fragments with a source indicated. If it is small, it is simpler to put it into the request whole. A comparison of approaches is in the article RAG by hand↗.