Skip to content

Systems and records

Contract negotiation decision dataset: capturing the reason behind each redline

By SourceX Editorial · Reviewed by Noah Loul ·

9 sections

Short answer

Legal workflow data captures the decision behind a redline when each negotiated issue is its own record: the clause and the position the company started from, every version and tracked change that touched it, who had authority to concede, the stated reason in counsel-approved nonprivileged words, and how the issue closed in the signed version. Tracked changes alone record who edited what and when, never why.

License terms

Contract negotiation

This page covers contract negotiation decision dataset: capturing the reason behind each redline.Illustrative

Key takeaways

  • Tracked changes record the author and date of an edit, never the reason, so the reason has to be captured outside the document.
  • Build records around the negotiated issue, not the individual edit or the clause, and hang versions, changes and comments off it.
  • Every concession needs an authority reference to an approval record dated before the turn that conceded.
  • Rationale must come from nonprivileged business correspondence or a summary counsel approves; privileged memos are not a source.
  • A record fails if its resolution contradicts the signed text or its revision chain never reaches the executed version.
  • Exclude issues that cannot be rebuilt from real documents rather than reconstructing reasons from memory.

Why tracked changes alone cannot explain a negotiated contract

Tracked changes explain what moved, not why it moved. A redlined Word file records insertions and deletions with an author and a date, and comments with an author, initials and a date, but nothing in the file format says which playbook position the edit defended, who approved the concession or whether the other side accepted it.

Microsoft's Open XML documentation shows the shape of that record. An inserted run is wrapped in a w:ins element whose attributes carry the author and the date of the revision, and a w:comment element carries an author, a date and initials. Those are the raw materials of a revision trail. They are also the limit of it: the file knows that a user changed the limitation of liability clause on a Tuesday, and nothing more.

The trail is also fragile. Microsoft's own sample for accepting all revisions removes the w:ins wrappers and keeps the inserted text, which is exactly what happens when a negotiator accepts changes before sending a clean copy. Once that clean copy becomes the next turn, the history of that turn lives only in the earlier file. A contract negotiation decision dataset therefore has to capture the reason and the linkage outside the document, before the redlines are flattened.

Should the record be built around the edit, the clause or the negotiated issue?

Build it around the negotiated issue. One issue, such as a supplier's request to cap its liability, usually spans several edits across several turns and sometimes more than one clause, while one clause can host two unrelated disputes. An edit-level record fragments the decision; a clause-level record merges decisions that had different owners and outcomes.

The issue record is the unit a reviewer can judge. It answers a complete question: what did the company want, what did the other side ask for, what was conceded, on whose authority and for what stated reason. Edits, comments and versions then hang off the issue as evidence, each with a pointer back to it.

This is also the difference between a decision dataset and a clause annotation set. The public CUAD dataset, built with legal experts at The Atticus Project, labels 41 categories of important clauses across 510 commercial contracts with more than 13,000 annotations. That is valuable for teaching a model to find a governing law or anti-assignment clause. It does not record how the clause got there, which positions were traded or who decided, and an issue-level record is how you add that layer to your own archive.

The issue rationale and revision linkage schema

The schema below is the minimum set of fields for one negotiated issue. Field names are suggestions; the purposes and validation rules are what matter. Every value comes from the matter file, the playbook or the approval record, and the rationale is either taken from nonprivileged business correspondence or written as a short summary that counsel approves for this use.

Keep identifiers pseudonymous from the start. The matter, the counterparty and every person should appear as stable IDs whose key stays with the company, so later de-identification does not break the links between records.

Agree the closed lists before coding starts. Resolution values, rationale sources and approver roles should be set by legal operations and counsel together, with a short definition for each, so two reviewers coding the same issue reach the same value. A small double-coded sample, compared field by field, shows quickly which definitions are too loose.

The issue rationale and revision linkage schema
FieldAllowed valuesWhat it recordsValidation rule
issue_id and matter_idStable pseudonymous IDsOne negotiated issue inside one matterBoth required; issue_id unique across the archive
clause_refsOne or more clause IDs from the version mapWhere the issue lives in the agreementEvery ID must exist in at least one linked version
opening_positionPlaybook position ID plus playbook versionWhat the company proposed first and the rulebook it came fromPlaybook version must be dated on or before the first turn
counterparty_requestShort neutral paraphraseWhat the other side asked for, in plain wordsRequired when the issue was raised by the counterparty
resolutionaccepted_ours, accepted_theirs, compromise, deferred, droppedHow the issue closedMust match the text of the executed version
fallback_usedFallback ID or noneWhich pre-approved fallback, if any, was offeredIf not none, the fallback must exist in the cited playbook version
authority_refApprover role ID plus approval record IDWho was entitled to concede and where the approval sitsRequired when resolution is not accepted_ours
rationale_summaryOne to three sentencesThe stated business reason for the outcomeRequired; source_of_rationale must be filled
source_of_rationalebusiness_correspondence, approval_note, counsel_approved_summaryWhere the reason came fromPrivileged sources are not an allowed value
revision_linksOrdered list of version and change IDsEvery turn and tracked change that touched the issueAt least one entry; last entry must be the executed version

Each version of the agreement gets its own record, and each version points to the version it revised. The W3C PROV ontology names this relation wasRevisionOf: a derivation where the new entity is a revised version of an original and keeps substantial content from it. Recording the prior version explicitly is what lets a reviewer rebuild the order of turns even when files were renamed, emailed or saved over.

At a glance

How versions, edits and comments link back to an issue

Below the version sit the changes and comments extracted from the document, each keeping the author and date the file recorded, plus the issue_id it belongs to. A tracked change with no issue is acceptable, since formatting fixes and typo corrections are real edits that decided nothing. A tracked change on a clause listed in an issue's clause_refs but missing from its revision_links is a linkage gap the validator should flag.

Take sent dates and senders from the document management system or the email that carried each turn, not from the file. Files are saved over, renamed and copied between matters, and their internal properties often show the last person who opened them rather than the party that sent them. Where a contract lifecycle platform stores versions, its version log is usually the best source for the chain; where turns were exchanged only by email, the transmittal messages are.

  • version_id, prior_version_id and the party that sent the turn (company, counterparty or outside counsel acting for either).
  • turn_number and sent_date, taken from the transmittal email or the document management log rather than the file's own properties.
  • change_id, change_type (insertion, deletion, move or formatting), the author ID and date from the file, and the issue_id or a no_issue marker.
  • comment_id, the author ID and date from the file, and a flag for whether the comment was internal or visible to the other side.
  • executed_version_id on the matter, so every issue can be checked against the text that was actually signed.
  • An exclusion record for every document withheld, with the reason category and the reviewer, so a gap in the chain is explained rather than silent.

What counsel has to remove before a redline history can be used

Counsel has to remove anything privileged or protected and decide what the remaining rationale may say. The reason a concession was made often sits in an email from in-house counsel to the business, and that email is the record most likely to be privileged. Federal Rule of Evidence 502 describes attorney-client privilege as the protection applicable law gives to confidential attorney-client communications, and work-product protection as the protection for materials prepared in anticipation of litigation or for trial. Whether a given note falls inside either depends on the facts, and only counsel can make that call.

That is why the schema restricts source_of_rationale. A rationale can come from correspondence between business people, from an approval note in the contract system or from a short summary that counsel reviews and approves for this purpose. It cannot be lifted from a privileged memo. Margin comments visible to the other side are generally a different category from internal comments, which is why the comment record carries a visibility flag.

Confidentiality is a separate screen from privilege. The other party's drafting, the commercial terms and any personal data in signature blocks and notices are governed by the agreement's confidentiality clause, the company's obligations to that party and privacy law. Removing names does not by itself give the company a right to use or license the text. This is general information, not legal advice; counsel reviews the specific matters, agreements and jurisdictions.

Worked example: one liability cap issue across four turns

Illustrative: a fictional software company negotiates a master services agreement with a fictional enterprise customer. The customer's first redline replaces the company's liability cap, set in its playbook at a multiple of annual contract value, with uncapped liability for data breaches. The table shows the four turns as linked records. No real matter, party or term is shown, and nothing here describes any company's actual data.

The resulting issue record reads: opening_position LOL-CAP-1x from playbook version 2026-03; counterparty_request uncapped liability for data security breaches; resolution compromise; fallback_used LOL-SUPERCAP-3x; authority_ref deputy general counsel role, approval record APR-0412; rationale_summary the customer's security review had passed and a separate higher cap for data breaches was within pre-approved fallbacks; source_of_rationale counsel_approved_summary; revision_links V1, V2 change C-17, V3 changes C-31 and C-32, V4.

Worked example: one liability cap issue across four turns
TurnVersion and senderWhat changed on the issueLinked evidence
1V1, company templateStandard cap of one times annual contract valuePlaybook position LOL-CAP-1x, version 2026-03
2V2, customerChange C-17 deletes the cap for data breach claimsTracked deletion with author and date; external comment asking for uncapped liability
3V3, companyChanges C-31 and C-32 add a separate cap of three times for data breach claimsApproval APR-0412 by the deputy general counsel role; fallback LOL-SUPERCAP-3x
4V4, executedCustomer accepts the separate cap without further editsExecuted version ID on the matter; signature date from the e-signature log

What a failing record looks like and which checks catch it

A failing record is one a reviewer cannot trust or cannot trace. Take the same issue recorded badly: resolution says accepted_ours, the executed version contains the three times cap, authority_ref is empty, the rationale reads per GC email, and revision_links stops at V3. Four checks fail: the resolution contradicts the signed text, a concession has no authority, the rationale points at a likely privileged source, and the chain never reaches the executed version.

At a glance

What a failing record looks like and which checks catch it

Most of these checks can be written as a JSON Schema plus a small script. JSON Schema 2020-12 provides required for fields that must be present, enum for closed value lists such as resolution and source_of_rationale, and dependentRequired for fields that become mandatory when another is present. Rules that compare records, such as matching the resolution to the executed text or the playbook date to the first turn, need a script that loads the issue, its versions and the playbook together.

  • Schema check: required fields present, resolution and source_of_rationale inside their enums, IDs in the expected format.
  • Authority check: any resolution other than accepted_ours has an authority_ref that resolves to an approval record dated before the turn that conceded.
  • Chain check: revision_links is ordered by turn, each prior_version_id exists, and the last link is the executed version.
  • Text check: the clause text in the executed version is consistent with the resolution value, reviewed by a person on a sample.
  • Playbook check: opening_position and fallback_used exist in the playbook version cited, and that version predates the first turn.
  • Privilege check: the rationale contains no quoted counsel advice, and every withheld document has an exclusion record.

Which gaps mean an issue should be excluded rather than repaired

Exclude an issue when the reason cannot be recorded without privileged material, or when the chain cannot be rebuilt from the documents the company actually holds. A reconstructed rationale written today from memory is a new opinion, not a record of the decision, and it should not be presented as one.

Some gaps are worth repairing. Missing sent dates can often be recovered from transmittal emails, and missing approval links from the contract system's approval log. Other gaps are not: if the only version history is a single executed PDF, there are no turns to link, and if the playbook in force at the time was never versioned, the opening position cannot be dated. Record those matters as out of scope with a reason, and keep the count, because the ratio of complete to excluded issues is itself useful evidence of how well the archive was kept.

Set the exclusion rule before anyone starts coding issues, and apply it to the whole sample rather than matter by matter. A team that decides case by case tends to keep the matters with the most interesting stories and drop the ordinary ones, which skews the set toward unusual negotiations. Write the rule down, record which reviewer applied it, and sample a few excluded matters for a second look so the rule is tested rather than assumed.

Preparing a redline archive for a licensing conversation

A company that keeps issue-level records like these holds something rarer than contract text: documented judgment about which positions were worth holding, tied to signed outcomes. Before any of it is used outside the company, the rights questions come first. Access to the files, privacy permission for the personal data inside them, ownership of the drafting and the contractual right to license are four separate questions, and de-identification answers none of them on its own.

For a legal department weighing that step, SourceX handles the rights review, contracting, preparation and delivery involved when a company licenses selected records to AI developers. Scope and terms are the company's to approve, and nothing reaches SourceX before the agreement is signed. The opening step is a brief assessment of the company itself, with nothing uploaded.

Frequently asked questions

What is a contract negotiation decision dataset?

It is a set of records in which each negotiated issue in an agreement is linked to the versions and tracked changes that touched it, the position the company started from, who approved any concession, the stated reason and the outcome in the signed contract. It differs from a clause dataset, which labels where clauses are but not how they were negotiated.

Can the rationale field quote emails from in-house counsel?

Not without counsel deciding the email is not privileged or protected and approving its use, which will often not be the case. The safer pattern is a short counsel-approved summary of the business reason, or a reason taken from correspondence between business people. Counsel reviews the specific facts; this is general information, not legal advice.

Do we need the original Word files, or are PDFs of each turn enough?

Original files are much better, because tracked insertions, deletions and comments carry author and date attributes that a flattened PDF loses. PDFs can still support the version chain if each turn is dated and its sender recorded, but change-level linkage then has to be rebuilt by comparing versions, which is slower and less exact.

How is a redline issue different from a clause annotation?

A clause annotation marks a span of text and says what kind of clause it is. An issue record describes a dispute over that clause: what each side wanted, what moved across turns and why the final wording was accepted. One clause can carry several issues, and one issue can touch several clauses.

What happens to issues where the history is incomplete?

Record them as excluded with a reason rather than filling the gap from memory. A rationale written years later is a new opinion, not evidence of the original decision. Keeping the count of excluded issues also shows a reviewer how complete the archive really is.

Sources

  • In Open XML, a tracked insertion is a w:ins element whose attributes record the revision author and date. Source
  • A Word comment is a w:comment element with author, date and initials attributes. Source
  • Microsoft's sample for accepting all revisions removes the w:ins wrappers and keeps the inserted runs, so accepted copies lose revision markup. Source
  • CUAD labels 41 categories of important contract clauses across 510 contracts with more than 13,000 expert annotations. Source
  • PROV-O defines wasRevisionOf as a derivation where the resulting entity is a revised version of an original. Source
  • JSON Schema 2020-12 validation defines the required, enum and dependentRequired keywords. Source
  • Federal Rule of Evidence 502 defines attorney-client privilege and work-product protection by reference to applicable law. Source

See if your company qualifies

A short company assessment. No data uploads are needed.

See if your company qualifies