Removing clutter to close deals faster
Commercial contracts often go through several rounds of negotiation. As attorneys trade drafts and mark up their proposed changes, strikethroughs and insertions multiply. Comments in the margin may reference terms that have already been changed. Attorneys have to sift through this thicket of redlines to see what’s new, a process that can be time-consuming. It’s not uncommon for a contract mid-negotiation to have more than 150 redlines — 95% of them old or already resolved.
At Crosby, agents and attorneys work together to make commercial contract review faster and better.
Agents take the first pass, reading hundreds of playbook rules in seconds to flag nonstandard terms and key issues for attorneys. But agents can struggle to parse messy documents.
within fifteen (15) days
Start with fifteen days
The original wording fits in a single text run.
<w:r><w:t xml:space="preserve">fifteen (15) </w:t></w:r>
Earlier this year, we noticed that agents’ performance declined with each successive contract version and each additional redline.
When agents fall short, our instinct is to fix them: to give them better prompts or more context. We took a different approach here: Rather than helping the agent read cluttered documents, we decided to de-clutter the documents.
Why reviewing redlined contracts is hard
Why it’s difficult for the attorney
When attorneys get a contract back from a counterparty, their primary question is: What changed? They’ll scan pages for edits and hover over redlines to see metadata such as author and timestamp. They have to reconstruct a timeline of who changed what, when.
This has a cost: As redlines accumulate, attorneys waste valuable time rereading terms and cross-referencing old comment chains. And it can be risky. Say a counterparty changes a liability cap from $300,000 to $30,000. That may be a single-character change — but it amounts to a 90% decrease in what a client can recover. If the change is made in a paragraph already rife with redlines, it might get overlooked by an agent or human attorney.
Why it’s difficult for the agent
While attorneys work in Word, the agent reads the underlying XML.
Authors and timestamps are included alongside every edit. Even so, it’s hard to reconstruct a chronology of changes. As one example, Word logs the time of each edit using the author’s local time zone. But no matter what time zone they're in, Word logs UTC. That means a redline made at 8 a.m. in San Francisco looks like it preceded a redline made at 10 a.m. in New York, even though it actually came an hour later. Recent versions of Word sometimes mark the true UTC in a separate field.
Redlines memorialize all the changes that have been made to a contract; they can’t just be deleted. But we wanted to make it easier for attorneys mid-negotiation to see the newest changes.
We did this in three steps: 1) identifying which party made each edit, 2) adding new edits to a changelog, and 3) generating a simplified document showing only the new changes: a true red.
Authors: identifying which party made each edit
Every tracked change carries a w:author attribute. But the same author might show up as “Jane Doe,” “jane doe,” or “Jane Doe [2]” (the label Word adds when one author’s edits are recorded under two identities, typically when they edit in more than one session).
Sometimes there are invisible zero-width characters. Other times, authors are team aliases or documents have been anonymized, with every edit attributed to a placeholder such as “Author,” “Autor,” or even “作成者,” depending on Word’s language setting when the file was anonymized. Word has a privacy setting that does destructive and non-reversible operations to remove all author metadata. We run into this frequently and need to rehydrate author data.
Before we can assign authors to a party, we canonicalize the name: stripping the suffix and hidden characters, standardizing caps and lower case, and ensuring placeholder names are actually treated as placeholders.
We assumed there would be a fixed set of people editing on behalf of any given party. That would mean it would take just a few negotiations with a party to recognize most of its authors.
With this hypothesis in mind, we started storing author affiliations in our database. Each author is recorded with up to three identifiers in Word: Microsoft account ID, email, and name. When a new document arrives, we match its authors on the strongest available identifier.
Here are a few ways we work through this when evaluating new authors:
- Document metadata: We check whether Word’s people.xml includes any usable author metadata.
- Group membership: We look to see whether the author is in any of Crosby’s Slack channels, and use the channel’s context to match them to a business.
- Name: We use text-matching algorithms and heuristics for parsing out company names.
- Public information: An LLM agent scours the web, mostly LinkedIn, to see where they work. It returns a confidence score, and we accept the LLM’s placement only if it’s high.
- Manual labeling: In the rare case when none of these steps is conclusive, we ask an attorney to label them.
Once every author is accounted for, we look at what’s changed.
Changelogs: recording what changed in each version of the contract
When we ingest a new document, we run it through similarity algorithms to check whether Crosby has seen an earlier version. For the first document in a negotiation, it records all tracked changes. For later versions, it adds only those changes not already in the changelog.
This is deceptively difficult. A single tracked insertion can be split into several insertions in the next version. Between edits, reviewers may accept part of a redline, strike a word inside it, or type beside it. Word re-cuts the markup each time.
For example, a counterparty replaces “sixty (60)” with “thirty (30)” in a payment clause. The counterparty’s deletion and insertion go into the changelog as two entries, each stamped with its author and timestamp. During review, our attorney adds “calendar” inside the counterparty’s insertion. Word then splits the counterparty’s insertion to accommodate Crosby’s.
<w:p><w:r><w:t>Customer may pay up to </w:t></w:r><w:del w:author="Counterparty Counsel"w:date="2026-04-02T15:10:00Z"><w:r><w:delText>sixty (60) </w:delText></w:r></w:del><w:ins w:author="Counterparty Counsel"w:date="2026-04-02T15:10:00Z"><w:r><w:t>thirty (30)</w:t></w:r></w:ins><w:r><w:t> days late.</w:t></w:r></w:p>
Before: one insertion
The document now holds two counterparty insertions, “thirty” and “(30),” where before there was one, “thirty (30).” We needed a mechanism to detect that these have already been logged. Timestamps already got us most of the way, but the data can be lossy (clients sometimes send Crosby a PDF or a copy of the original). So we started matching on content, too — comparing each redline in a new document against the changelogs stored for the negotiation: recognizing an edit whether it comes back whole, in pieces, or fused with its neighbors, and recording only what’s left over.
True reds: producing a simplified document showing only the new redlines
Historical redlines are saved and we snapshot document files, so that we can edit the XML files without worrying about losing data. To create a true red, we must accept redlines made prior to the counterparty’s newest redlines.
Accepting a redline that deletes text takes one click in Word. In XML, we need to reposition comments first.
A comment, for instance, is positioned by invisible range markers around the text it refers to. If that text is part of a deletion we’re accepting, we lift these markers out of the redline and leave them where the text was, so the comment retains its place in the document.
Redlines can also sit in headers, footers, footnotes, and endnotes, each stored in its own XML file. We rewrite each file, and when an accepted deletion takes out a footnote’s only reference, we remove the footnote too, just as Word would.
If we miss a single step here, Word may refuse to open the file.
Some documents can’t be cleaned up safely. When authors delete text from their own previous redline insertion, Word doesn’t record a deletion; it shortens the insertion and keeps its original date. So if the counterparty’s earlier redlines are still in the document, the counterparty can modify them in later rounds without leaving a trace. A date cutoff would accept those changes as old, and the modification would slip through.
For that reason, we don’t create a true red copy if Crosby’s edits are interwoven with the counterparty’s. Creating a true red with each version is what keeps the process safe: once old redlines become plain text, anything edited later shows up as new redlines. The agent then receives the changelog and the simplified document as context, while attorneys can view a summarized timeline of previous rounds.
We want to make life easier for opposing counsel, too. Before returning contracts, Crosby accepts earlier redlines so that they see only the latest redlines.
Draft
Use the arrow keys to explore drafts. Press Escape to dismiss the tooltip.
| Draft | Without true reds | With true reds |
|---|---|---|
| 1 | 34 | 34 |
| 2 | 70 | 22 |
| 3 | 100 | 10 |
| 4 | 148 | 11 |
| 5 | 161 | 8 |
| 6 | 201 | 8 |
| 7 | 262 | 5 |
We’ve made a lot of progress, but there’s so much more to do. Next, we will be working on partial true reds: keeping chunks of redlines that are needed across versions and clearing the rest
If you find any of these problems interesting, we're hiring at crosby.ai/careers
Acknowledgements
Huge shout-out to Serge Nasr for building true reds; Ariba Khan, Aveek Duttagupta, Emma Hartley, Logan Willmott, and Raymond Lin for helping design and debug.







