# How to Run a Two-Week AI Pilot That Shows What an Agent Costs and How Often It's Wrong

> Your team's finished files are the answer key. Price the job as it is done today, seal a test set sized to the error rate you can live with, and sign the pass rule before any result. Ten working days later, the rule says scale, fix, or kill.

By Vlad Shvets, Partner @ Qvery · Published 2026-10-26 · 22 min read
Canonical: https://qvery.ai/blog/ai-pilot-plan/

The standard advice for piloting an AI tool on documents is sound as far as it goes: pick one task, write the success criteria first, test it on real work, and decide at the end whether to scale or stop.

Getting the right answers to test against is the slow part: someone writes them out by hand before the test starts, or the pilot runs on live work until enough cases show how often the tool is wrong and what each document costs.

There is a faster test in your files: the work your team finished last quarter **already holds checked answers**, so a pilot can replay it against the agent and score every document.

Pick one document task, price it as it is done today, seal a test set that neither the agent nor the vendor sees until day 8, and **sign the rule** that decides the result before anything runs. Over the next 10 working days you clean the inputs, break the agent on your ugliest files, and score the sealed set once. Day 10 applies the rule: scale, fix, or kill.

It fits a task with a right answer, such as reviewing a contract against your positions, abstracting a lease, or matching an invoice to its order. Adoption and next month's live volume are the step after a pass.

## Pick One Document Task Whose Right Answers Are Already in Your Files

A pilot answers one question, so it tests one task, and each task needs **its own sealed set** and its own reviewer's hours.

Three things make a task pilotable. **A right answer exists** that two of your people would mostly agree on: whether a clause sits within your position has one; whether a contract is a good deal doesn't.

**It recurs**, so last quarter holds enough finished cases to seal a set. And **one person owns it** and can say what right means without a committee.

Pilot plans treat the answer key as something to build, and you probably own one already: a reviewed contract sits beside the marked-up version your lawyers sent back, an abstracted lease in the property system, a posted invoice in the accounting system. Each pair is **a question and its answer**, checked by someone you trust.

That is why two weeks is enough: a pilot that waits for new work needs **weeks of live cases**, while one that **replays finished work** runs a quarter's documents through the agent in an afternoon and has them scored within days.

Checked is not the same as right. Before day 1, have the second reviewer re-check a small random slice of the pairs, and if it turns up serious errors in the old answers, fix the key first: an agent that repeats an old mistake will score as a match.

The pairs also have to be **findable**. Choose a task whose final answer sits in a system, so building the key is an export, not a hunt through four inboxes for the version that went out.

**One document task per industry, and the answer key you already hold**

| Industry | Document task | The answer key you already hold | A serious error | A cosmetic error |
|---|---|---|---|---|
| Legal | Review third-party contracts against your positions | The version you sent back, with the reviewer's notes | An uncapped liability marked as fine | A clause filed under the wrong heading |
| Real estate | Abstract a lease into the property system | The abstract your team entered | A wrong rent step, expiry, or notice date | An address written another way |
| Logistics | Audit a carrier invoice against the rate confirmation | The invoice as approved, with its adjustments | A charge passed that the rate confirmation doesn't allow | A carrier name spelled differently |
| Finance | Match a supplier invoice to its order and receipt | The posting and the match decision | A wrong amount, supplier, or duplicate passed | A date in another format |

The running example from here on is the first row: your team reviews other companies' paper against a short list of positions on liability, indemnity, governing law, termination, and confidentiality.

The same logic runs our own work. When a company brings Qvery a job like this, we [learn how the team does it](https://qvery.ai/blog/workflow-mapping-ai-agents/), agree a fixed price for a defined result before anything starts, and commit to a first working result in two weeks, measured in hours saved and errors avoided.

## Before Day 1, Fence the Agent In and Time What the Job Costs Today

The worry is fair: you are about to hand your contracts to software you don't control. Five decisions, made before any file moves, settle what it can read, keep, and write.

1. **Name the files that never leave** In legal work the line is client information: the ABA's Formal Opinion 512 says a lawyer needs the client's informed consent before putting information about the representation into a self-learning tool whose output could disclose it to others[^1].
2. **Get the provider's terms in writing** Whether it trains on your files, how long it keeps them, how they are deleted, and who else processes them. OpenAI says it does not train on data from its business plans or its API by default,[^2] while ChatGPT's personal Free, Plus, and Pro workspaces share data for training unless the user turns it off,[^3] and Anthropic says it does not train on data from its commercial products by default.[^4]
3. **Open one place, read-only** A folder or a system view that holds the pilot's files and nothing else on the drive.
4. **Send its answers to an approved sheet** During the pilot the output goes to a sheet or folder your company already approves for this data, never into the contract system, the property system, or the ledger.
5. **Read through the access production will use** If the agent will read the contract system in production, the pilot reads through that same access, permissions and formats. A pass on files someone exported by hand says nothing about any of them, so it can't decide scale.

![It may: read one folder read-only, via production access, and write answers to one approved sheet. It may not: write into a live system, open off-limits files, or see the sealed set before day 8.](https://qvery.ai/blog/ai-pilot-plan/illustration-fence.webp)

*Write the left panel down and sign it before the first file moves.*

If a vendor runs the agent, it configures on the tuning documents you give it and nothing else, and every setting, playbook entry and manual fix is written down, so you can tell the product's output from a person's work behind it.

The vendor **never receives** the sealed set before its one run on day 8, and never keeps or scores it. A vendor that won't run a read-only pilot on terms that rule out training on your files has answered before day 1.

Tell your team what this is before anyone times anything. Their finished work is the answer key and their judgment settles the disputes, so the pilot measures the job, not them.

Then time the work as it is done today, over one or two weeks before day 1: every case that arrives, not the ones someone picks, until you have about two dozen, start to finish, from the first read to the notes and the back and forth over the odd clause.

**Don't ask people** how long it takes. In METR's randomized trial of early-2025 AI tools, 16 experienced software developers expected AI to make them 24% faster, believed afterwards that it had made them 20% faster, and took 19% longer.[^5]

METR said in February 2026 that the tools developers used by then likely made them faster than that study found, and that people's reports of their own speed-ups can still be quite unreliable.[^6] The study proves nothing about your reviewers, who aren't developers, but it is reason enough to time the work with a clock.

From the timing, write down minutes per document, how many cases left the usual path or came back for rework, and **the cost per finished document**: those minutes at the hourly cost your company already uses for the role.

Now put a price on the job. Say the clock gives 45 minutes a contract, and a lawyer can finish the agent's prepared review in 15; both are assumptions to replace with your own.

At the example quarter's 220 contracts, today's work is **165 hours a quarter**, and the agent's is 55, plus the exceptions it hands back and the tool's price.

The difference before exceptions, **110 hours a quarter**, is time the agent could free if it passes. Take the exceptions' hours off it and price what is left at your hourly cost: that is the most the agent can cost each quarter to build and run and still break even. Those freed hours become money only when they go to other work.

Price both sides per usable document, with the review a person will still do: if someone reads every output for the first months, count that, not a lighter check you might switch to once the agent has passed.

The pilot's own hours (the setup, the preparation, the reviewers' scoring days) are a one-time price, paid whatever the result and kept out of the comparison.

A single uncapped liability marked as fine can cost more than all of those hours, so the rule counts serious errors before it counts savings.

Hand Us the Document Job You Just Timed: https://calendly.com/qvery-vlad/30min

## Size the Sealed Test Set by the Error Rate You Can Live With

Pilot advice says to test on real documents and stops before saying how many. Start with the unit: score each sealed document **pass or fail** on its worst error, because a review that missed one uncapped liability failed, however many clauses it caught.

Keep serious narrow: an error that would change a decision or create a legal or financial exposure, and a right answer that rests on a clause that doesn't say it, since it is right by luck until the versions differ. A clause filed under the wrong heading is cosmetic, logged but never a fail.

Then the arithmetic. Statisticians call it the rule of three[^7]: if you see zero events in N independent trials, the true rate could still be as high as **about 3 in N**, at 95% confidence.[^8]

A clean run on 100 sealed contracts means you can be 95% confident the agent's serious-error rate on documents like them is **below 2.95%**: a ceiling of about three in a hundred, not a zero.

**A Clean Sealed Set Proves Less Than It Looks** (upper limit on the error rate)

A clean run on 100 sealed documents still allows a true serious-error rate up to 2.95%, and one serious error found raises that ceiling to 4.66%.

| Label | No serious error found | One serious error found |
|---|---:|---:|
| 25 documents | 11.29% | 17.61% |
| 40 documents | 7.22% | 11.32% |
| 50 documents | 5.82% | 9.14% |
| 75 documents | 3.92% | 6.17% |
| 100 documents | 2.95% | 4.66% |
| 150 documents | 1.98% | 3.12% |
| 200 documents | 1.49% | 2.35% |
| 300 documents | 0.99% | 1.57% |

The 95% upper limit (one-sided) on the serious-error rate once a sealed set of each size finds zero or one serious error: every rate above the plotted point is ruled out. Each document is scored pass or fail on its worst error; the bound assumes agreements drawn at random, one at a time, from the work the agent will face. Source: Qvery's calculation (exact binomial bounds); the rule of three, Hanley and Lippman-Hand, JAMA (1983)

Read the chart backwards and it becomes a sizing rule. Decide the highest serious-error rate you could live with on this task, then hold back enough documents to rule it out: **59 clean documents** rule out a rate above 5%, **99** rule out 3%, and **299** rule out 1%.

The bound rests on four conditions, each a choice you make when you draw the set.

> 📖 **What a clean sealed set assumes** 
> - The documents are drawn at random from the work the agent will face, across everything you exported; a counterparty that dominates the export is tested as its own type.
> - Each document is scored on its own, by the same rule.
> - Each draw is one whole agreement, never a group, so every document is a separate trial. Agreements on one template share its failure modes; the bound speaks for the mix of templates you drew from and says little about any single one.
> - The bound covers documents like those and nothing else. A new template, counterparty or client sits outside it until you test it.

The real cap on the set's size is **your reviewer's time**, because scoring means comparing the agent's answer with the key, document by document, and ruling on every disagreement. At 10 minutes a contract, 100 contracts take about 17 hours to score.

Timing the review on two dozen of them, at the example's 15 minutes, adds another 6 hours. That makes about 23 hours in all, more than one reviewer has in days 8 and 9, so split the set with the second reviewer, about 11 hours each, and start as the outputs land.

**Draw a second sealed set**, the reserve, at the same time and lock it away too, because a set you have already looked into can't test a fix. How large you draw it sets what a fix round can prove, and the pass rule below spells that out.

## Sign the Pass Rule Before Anyone Has Seen a Result

A rule written after the results arrive is a negotiation. Write it before day 1, with the person who owns the task, and sign it.

> 📌 **The pass rule, with the blanks to fill** 
> - **Scale** if no more than [k] of the [n] sealed documents carry a serious error, the cost per usable document is at least [x]% below today's, and the exceptions the agent hands back fit in [hours] a week of the current team's time.
> - **Fix** if the misses trace to causes you can name and correct in one more round, tested on the reserve set by [date]. A clean round on a reserve as large as the sealed set decides scale; on a smaller reserve it earns one more full-size sealed test under this rule, and nothing after it. A fail at either step is a kill.
> - **Kill** otherwise. No second fix round, no new definition of serious, and no extension the rule doesn't name.
> - **Types** covered: [document types]. A type that may scale on its own needs its own sealed count.
> - **Reviewer**: [name]. Second reviewer: [name]. Decision by [owner] on [date].

Filled in for the example quarter, the rule seals 100 contracts and passes at no more than one with a serious error, which rules out rates above 4.66%. Say the owner sets the cost margin at 30% and the exceptions at three hours a week, about four contracts at today's 45 minutes.

The reserve is 40, which rules out rates above 7.22% at best, so a clean fix round here earns the full-size test, drawn from next quarter's finished files, rather than a scale decision.

Under the rule, write the list of serious errors for this task, with an example of each from last quarter's files, and do it now: a list written after the misses are known gets written around them.

![A two-week calendar. Week 1: seal the sets, clean the inputs, ugly files. Week 2: ugly files, scope in writing, the sealed run on day 8, scoring on day 9, the decision on day 10.](https://qvery.ai/blog/ai-pilot-plan/illustration-ten-days.webp)

*The sealed set is drawn on day 1 and stays shut until day 8; until then the work runs on the tuning pile.*

## Days 1 to 3: Seal the Test Set, Then Clean What the Agent Reads

On the morning of day 1, before anyone opens a document, export the quarter's finished pairs as a list: one row per agreement, its amendments with it, and the counterparty's template beside it.

Let a spreadsheet's random function pick agreements **one at a time** until the sealed set and the reserve reach their sizes. Any type the rule lets scale separately is drawn separately, to the count the rule gives it.

Then set aside every other agreement on a template a locked one uses, so no counterparty's paper sits both in a locked set and in the files the agent is tuned on. The more contracts each counterparty sends, the more sit out.

If most of your paper comes from a few counterparties, that can leave almost nothing to tune on. Then keep out of tuning only each locked agreement's own versions and amendments: the test meets those counterparties' paper the way production will, after the agent has been tuned on it, and a new counterparty stays outside the bound.

Move both locked sets into a folder **only the scorer** can open. What remains is the tuning pile, and the worst of it the ugly pile.

![Dots, one per contract: 100 sealed and 40 reserve locked away; 20 that share a template with a locked one set aside; a tuning pile of 60 open from day 1, its 20 worst marked as the ugly pile.](https://qvery.ai/blog/ai-pilot-plan/illustration-file-split.webp)

*Pick the locked contracts one at a time at random, set aside the rest of their templates, and take the ugly pile from what is left to tune on.*

From then on nobody tunes against the sealed set, and that includes you. Google's machine-learning course says test sets "wear out" with repeated use: the more often one guides changes, the less it says about the next document.[^9]

Days 2 and 3 go to the inputs, because an agent can only be as right as what it reads.

**What the agent reads, what goes wrong with it, and what days 2 and 3 do about it**

| Input | What goes wrong | What to do |
|---|---|---|
| Unreadable files | Scans with no text layer, photographed signature pages, one PDF holding twelve documents | Run them through text recognition or set them aside, and note which |
| Two versions of one document | A draft and the signed copy in one folder, so the agent answers from the wrong one | Keep the source of truth and remove the other |
| Your own vocabulary | What your team means by "the MSA", "our paper", or "the cap" | Write each down in a line, so the instructions use your words |
| The positions | The checklist the agent reviews against | One position per line, in the words your reviewers use |

## Days 4 to 7: Feed It the Ugliest Files and Log Every Miss

The tuning pile is where you try to break it. Pull its worst paper into the ugly pile: heavily negotiated agreements, a counterparty's old template, a carve-out three pages away from the clause it changes, side letters, a bad scan, defined terms that shift halfway through.

The failures to log are plain ones. In one in-house legal team's trials of three tools on third-party NDAs, configured by the vendors on the team's own playbook, the tools put clauses in the wrong place, duplicated language, and misread defined terms.

And the miss that matters can be a single buried line: in one law firm's trials of three systems, about three weeks with each, a line in the intake notes should have disqualified the prospective client, and every system missed it.

A named reviewer logs every miss with one of three routes: **an input to fix** (the scan, the version), **an instruction to fix** (the position was ambiguous), or a case to put **out of scope** (the agent won't see side letters in production either, so a contract with one goes to a person).

A narrower scope is an allowed outcome of these four days, written into the pass rule before day 8 with the type it leaves out. The signed ceiling on the error rate does not move.

On day 9 the scorer sets every sealed document of that type aside before counting, and uses the same bounds to work out how many serious errors the documents left may carry: fewer documents prove less, so that number can fall, even to none. The cost line counts the excluded share as work people still do, so shedding hard cases can't buy a pass.

Shrink the set far enough and no result can pass: in the example, fewer than 63 sealed contracts can't rule out rates above 4.66% even with none wrong.

So narrow the scope only by a type you can count from the export's list, without opening a sealed document, and only if enough remain; otherwise treat the narrowing as the rule's one fix, ending in a full-size sealed test of the narrowed task.

### If You Have No Tool Yet, Run It on an Assistant Before You Buy One

Claude or ChatGPT, on a business plan inside your fence, can run the same review one contract at a time.

Because someone feeds it the files by hand, it tests the task and not your production access: a pass tells you the job is worth buying a tool for, not that you can scale, and the tool you buy gets its own pilot on a fresh sealed set.

The prompt below turns its answer into something you can score: one row per position, the section it relied on, the exact words copied from the contract, and NOT FOUND where the contract is silent, so a gap can't be filled with what contracts of that kind usually say.

**The review prompt**

```
Review the attached contract against our checklist below. Use only the attached contract. Do not use general knowledge or what contracts of this kind usually say.

Return one row per checklist item, as a table with these columns:
1. Item: the checklist item, word for word.
2. What the contract says: one sentence, or NOT FOUND.
3. Matches our position: YES, NO, or UNSURE.
4. Where: the section number, and the page if the contract shows one.
5. Exact words: the sentence or clause you relied on, copied exactly, or NOT FOUND.

Rules:
- If the contract does not say it, write NOT FOUND. Never fill a gap with a typical term.
- If a definition, schedule, exhibit or another section changes the answer, cite that section too.
- If a figure is blank or redacted, say so instead of guessing it.
- If the contract points to another document for the answer, name that document and write NOT IN THIS FILE.
- Return the table only.

Our checklist:
1. Limitation of liability: [our position]
2. Indemnity: [our position]
3. Governing law: [our position]
4. Termination: [our position]
5. Confidentiality: [our position]
6. [your next item]: [our position]
```

We ran it in October 2026 with a Claude model as a plain chat assistant, on a public, partly redacted supply contract filed with the SEC.[^10] All nine lines it quoted were in the contract word for word, and it said so where a figure was blacked out; one run shows what the prompt makes checkable, not any tool's accuracy.

Then we planted one sentence in a definition, pages away from the liability section, removing the cap for later shipments. The assistant found it and quoted it in the liability row, and **still marked the row UNSURE** rather than NO.

That is the lesson for day 8: score what each row found and what it concluded, never the tool's verdict column on its own.

## Days 8 and 9: Run the Sealed Set Once and Score Each Document on Its Worst Error

Day 8 is the only day the sealed set is opened. **Freeze the setup** the evening before: the instructions, the positions, the settings. Run all the sealed documents in one go, with nobody fixing anything between documents, and save the output exactly as it comes. Then score each document against the answer key:

**The score sheet: seven verdicts and how each counts**

| Verdict | What it means | How it counts |
|---|---|---|
| Match | The agent agrees with the key and cites the right place | Pass |
| Serious miss | The key flags a deviation the agent missed | Fail |
| Serious false answer | The agent states what the contract doesn't say, or cites the wrong place | Fail |
| False flag | The agent flags a deviation that isn't there | Pass, review time counted; fail if acting on it would change a decision |
| Unsure | The agent quotes the right clause but won't decide | An exception, priced at today's minutes; fail if it quotes the wrong clause |
| Cosmetic | Right substance, wrong heading or wording | Pass, logged |
| Key was wrong | The agent is right and last quarter's answer wasn't | Pass, logged as a finding about the old work |

The score comes from **a person**, or a formula where a field has one right value, never from the tool's report on itself. One person asked an assistant to confirm that two files matched cell by cell and was told they tied perfectly; every cell was off.

Every disagreement goes to **the other reviewer**, the one who didn't score that document, because last quarter's answers carry errors too. When the agent turns out to be right and the old review wrong, that is a finding about your current process, and it counts for the agent.

**Tips**

> First rule of thumb is to never take the sales rep's word -- test it for yourself.
> ([r/legaltech · Jan 2026](https://www.reddit.com/r/legaltech/comments/1qop0f3/getting_pitched_ai_for_contract_review_how_do_i/o2astk2/))

> Test the results, daily, against the original tool.
> ([r/Accounting · Jun 2026](https://www.reddit.com/r/Accounting/comments/1ue5zr7/i_automated_a_bank_reconciliation_process_now_my/otizlgy/))

> AI hallucinates, and makes mistakes. That doesn’t mean it isn’t a useful tool, but it needs external verification - you can’t rely on AI to check the work of AI.
> ([r/legaltech · Jan 2026](https://www.reddit.com/r/legaltech/comments/1qop0f3/getting_pitched_ai_for_contract_review_how_do_i/o27r01g/))

Time the review apart from the scoring, on a random two dozen of the sealed documents: the minutes from opening the agent's output to a usable result, false flags included.

Take them before the reviewer opens the key for that document and, where you can, give each reviewer documents they didn't review last quarter, so the minutes are the ones production will pay.

Day 9 ends with four numbers: **k**, the documents with a serious error; the false flags per document; the exceptions, priced at today's minutes; and the cost per usable document.

Keep the exceptions apart from k: an agent that marks every row UNSURE makes no serious errors and saves no time, and only the cost and exception lines stop it.

## Day 10: Let the Rule Decide, Once You Know the Pass Is Real

Before you read the rule, check that a pass would mean what it says.

### A Pass Doesn't Count If Production Couldn't Repeat It

- **It was right for the wrong reason.** The score sheet already fails it as a serious false answer, but only where someone checks the quoted words and not just the verdict. In a 2024 test of the AI legal research tools sold by LexisNexis and Thomson Reuters, Stanford researchers found them hallucinating between 17% and 33% of the time on research questions,[^11] and named this failure: a response "could be correct but improperly grounded," citing a source that doesn't support it, which "misleads the user in dangerous ways."[^11]
- **Someone looked at the sealed set.** If anyone changed the setup after seeing sealed documents, the result describes those documents, not your next ones. The reserve becomes the test, and it spends the rule's one fix round.
- **The review ate the saving.** Accuracy held, but checking each output took nearly as long as doing the work. One team that audits its trials on recent deal materials, timed to a usable result, found the drafting quicker and, for many tasks, the proofing and checking eating most of the gain. The cost line is what catches it.

Then read the rule as written, and nothing else. **Scale** needs all three of its lines: k or fewer serious errors, the cost margin cleared, and the exceptions inside the named hours.

In the example, a day 9 line of one serious error, a cost 40% below today's and two hours a week of exceptions is scale; two serious errors make it fix or kill, however large the saving.

Scale can be partial: if leases on one template passed and leases on another didn't, scale the first and keep people on the second, as long as the rule named those types before day 1 and each had enough sealed documents of its own to say so.

**Fix** and **Kill** go exactly as the rule says, and a kill is a result: two weeks and the reviewers' time bought a clear answer about a task that isn't ready, or a tool that isn't.

## After a Pass, Review Follows the Risk, and a Person Keeps Signing

A pass says the agent's serious-error rate on documents like your sealed set is probably below a bound. It doesn't say checking can stop.

So review changes shape rather than disappearing. Keep a person on every document where **an error would be expensive**, chosen by what you know before the agent reads it: a new counterparty, client, or template, and a contract above an amount you name. **Sample the rest**, and grow or shrink the sample with what it finds.

Write down what sends one document to a person at once (a NOT FOUND on a position that should be there, an UNSURE on liability, a side letter or another case the pilot put out of scope).

Write down, too, what sends the whole agent back to full review: one serious miss in the sample, or any change to the model or the instructions.

Lawyers already have a rule for this. The ABA's Formal Opinion 512 says that relying on an AI tool's output without an appropriate degree of independent review could breach the duty of competence, the degree depending on the tool and the task.[^1]

Its example reads like this pilot: a lawyer who tested a tool on a smaller set of long contracts, checked them by hand and found its summaries accurate would not necessarily re-read the whole set.[^1] The lawyer still "is fully responsible for the work on behalf of the client," whatever level of review they choose.[^1]

Outside law the opinion binds nobody, but its test is worth borrowing: the level of review follows the tool and the task, and the person who signs off on the work today **keeps signing** after the pilot, opening fewer documents only as far as the samples allow.

If you do one thing this week, **export and count** last quarter's finished pairs for one task. That count, less a tuning pile and a reserve, caps the sealed set, and so the lowest error rate your pilot can rule out, before anyone has opened a tool.

Plan the Next Jobs Your Company Hands to AI Agents: https://calendly.com/qvery-vlad/30min

## Frequently asked questions



### How long should an AI pilot last?

Ten working days, after one or two weeks of preparation: the fence, the key check, the timed baseline, and the signed pass rule. A fix adds a round on the reserve with its own date and, when the reserve is smaller than the sealed set, a full-size test on next quarter's finished files.

### How many documents do I need for an AI pilot?

Enough to rule out the error rate you can't accept, with the documents picked singly at random and each scored pass or fail on its worst error. At 95% confidence, 59 clean documents rule out a serious-error rate above 5%, 99 rule out 3%, and 299 rule out 1%. The reserve and the tuning pile come on top.

### How do I know if the AI pilot worked?

It worked if the sealed set met all three lines of the rule you signed: no more than the agreed number of serious errors, a cost per usable document below today's by your margin, and exceptions inside the hours you named, with the agent reading through production's access and nobody having looked at the set beforehand.

### When should I kill an AI pilot?

When the sealed set fails the rule and the misses don't trace to causes you can fix in one round, or when that round, or the full-size test a smaller reserve earns, fails. A vendor that won't run the pilot read-only, on terms that rule out training on your files, has settled it before day 1.

### Who reviews the AI output during the pilot?

The person who owns the task today and a second reviewer, who split the sealed set and settle each other's disagreements; the owner signs the decision. Neither the tool nor the vendor scores it.

### Should the vendor see the test set?

Not before the run. It configures on a tuning pile you give it, and the sealed set stays with your scorer until day 8; the vendor keeps no copy and scores nothing. A set it saw beforehand tests how well it was tuned to those documents, not how it will do on your next ones.

### Can we pilot with ChatGPT or Claude before buying a tool?

Yes, as a test of whether to buy one: one document at a time, on a business plan that keeps your files out of training, only with documents your policy lets leave your systems, and with the section and exact words behind every answer. In legal work, check client consent first. Scaling waits for the tool you buy to pass its own sealed test on production's connection.

### What if our past answers were wrong?

Some will be. Disagreements go to the second reviewer, and when the agent is right and the old answer wrong, it counts for the agent. If the slice you re-check before day 1 turns up serious errors, fix the key before you trust any score.

## Sources

[^1]: American Bar Association, "Formal Opinion 512: Generative Artificial Intelligence Tools" (2024), https://www.americanbar.org/content/dam/aba/administrative/professional_responsibility/ethics-opinions/aba-formal-opinion-512.pdf
[^2]: OpenAI, "Business data privacy, security, and compliance" (2026), https://openai.com/business-data/
[^3]: OpenAI Help Center, "Data controls in ChatGPT" (2026), https://help.openai.com/en/articles/8983130-what-is-the-chatgpt-enterprise-and-team-data-policy
[^4]: Anthropic Privacy Center, "Is my data used for model training?" (2026), https://privacy.claude.com/en/articles/7996868-is-my-data-used-for-model-training
[^5]: METR, "Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity" (2025), https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/
[^6]: METR, "We are Changing our Developer Productivity Experiment Design" (2026), https://metr.org/blog/2026-02-24-uplift-update/
[^7]: JAMA, "If nothing goes wrong, is everything all right? Interpreting zero numerators (Hanley and Lippman-Hand)" (1983), https://doi.org/10.1001/jama.1983.03330370053031
[^8]: JAMA, "If Almost Nothing Goes Wrong, Is Almost Everything All Right? Interpreting Small Numerators (Newman)" (1995), https://jamanetwork.com/journals/jama/article-abstract/389714
[^9]: Google for Developers, "Machine Learning Crash Course: Dividing the original dataset" (2026), https://developers.google.com/machine-learning/crash-course/overfitting/dividing-datasets
[^10]: U.S. Securities and Exchange Commission, "Dot Hill Systems Corp., Form 10-Q, Exhibit 10.6: Development and OEM Supply Agreement with Network Appliance" (2005), https://www.sec.gov/Archives/edgar/data/1042783/000110465905054001/a05-17947_1ex10d6.htm
[^11]: Journal of Empirical Legal Studies, "Hallucination-Free? Assessing the Reliability of Leading AI Legal Research Tools" (2025), https://arxiv.org/abs/2405.20362