Ran an obligation audit on a service contract. Forty-three clauses. First attempt I sent the whole document in one call and asked the model to return an assessment for each clause.
The output looked complete. When I checked against clauses I knew well, clause 28 kept coming back with indemnification language that wasn't in clause 28. It was from clause 11. The model was pulling context from elsewhere in the document rather than working from the specific text in front of it. The problem wasn't uniform either. Clauses toward the end of the document were noticeably less accurate than the ones near the top.
So I switched to one call per clause. Extract the clause text, build a prompt with only that clause plus whatever background applies to the whole contract, and run it. Forty-three calls.
The cross-contamination stopped. The other thing that changed: when a call fails now, it fails on one clause. I rerun that clause. With the original approach, a single failure on a forty-three clause contract meant either rerunning everything or accepting a gap in the results.
The latency tradeoff is real. I moved to concurrent calls with a semaphore to limit how many run at once, which brought wall-clock time down to something usable. The output also materializes incrementally, so if something goes wrong partway through, the completed clauses are already saved.
Where it gets messier is deciding what counts as a clause. In a well-drafted contract with clean numbered sections, the chunking is straightforward. I've been working on a construction subcontract recently where definitions are scattered through the body text rather than collected in one section, and several obligation clauses reference terms that are only defined six pages earlier. Including referenced definitions inline in the prompt has helped, but it's not a general solution. Documents that cross-reference heavily don't chunk cleanly no matter what heuristic you use.