Legal Teams// diagnostic

The extraction found the indemnity and got the direction wrong

In short

Storing an indemnity as present stores almost nothing. Direction, triggers and control of the defence fail separately: passive drafting hides the actor, mutual clauses state the roles once as placeholders, and the defence mechanic sits in a sub-clause the segmenter cut away. Grade 10 contracts on those 4 answers.

Key takeaways

  • Detection is easy and attribution is not. The clause is found; the party under it is inferred, and inference is where it breaks.
  • A mutual indemnity is 2 obligations. An extractor emitting 1 record per clause reverses one of them roughly half the time.
  • Score direction, triggers and defence control as 3 separate numbers. A document-level pass rate hides which of them is failing.
  • A trigger list reading short and generic is usually a cross-reference the extractor never followed into the Schedule.
  • Empty defence control beside a populated indemnity is a segmentation symptom, not a reading-comprehension one.
  • An unresolved Indemnifying Party should be stored as unresolved. A guessed one is a wrong answer wearing a confident field.

The clause was found. The record says this agreement contains an indemnity, and that is true. It does not say who owes it, what sets it off, or who runs the defence when a claim lands, and those are the facts anyone opening the record needed. A missing field announces itself. A field reading "indemnity: present" looks like work that was done.

Direction fails first because English lets a drafter state an obligation without naming the person under it, and indemnity drafting does this constantly. Finding the clause is text matching, which models are good at. Attributing it means resolving "the Indemnifying Party" or a bare passive back to a name in the Parties clause — a parsing problem over language written for a lawyer with the definitions open, and it fails quietly.

Ask 10 contracts who owes whom, and mark every answer

Change nothing until you know which of the 4 answers is wrong. The sample has to be small enough to grade in an afternoon and structured so a disagreement points at a cause rather than at a feeling.

  1. Pull 10 executed agreements spanning the paper you actually receive. Mix your own template with counterparty paper: failure rates differ enough that a sample drawn only from your template will look reassuring, which is the wider trap in reviewing on the other side's paper.
  2. Write the 4 answers by hand before opening the stored record. Indemnifying Party, Indemnified Party, triggering events, and who controls defence and settlement. Reading the record first contaminates the grading, because a plausible wrong answer is hard to un-see.
  3. Score the 4 fields separately rather than scoring the document. One right-or-wrong per contract hides the shape: direction can sit at 9 of 10 while trigger scope sits at 4 of 10, and those numbers demand different fixes.
  4. Label each disagreement by cause. Party absent, party wrong, triggers truncated, defence mechanic missing, mutual read as one-way. 5 labels are enough for a first pass and they map onto the table below.
  5. Count the mutual clauses separately. If only 2 of the 10 are mutual, the sample cannot tell you whether mutuality is handled — only that the extractor is right most of the time, which you already suspected.
  6. Keep the 10 graded documents. They are the regression set for every later change, and rebuilding them in 3 months costs more than the afternoon did.

An indemnity is 5 facts, and "present" is not one of them

Fix what a correct record contains before diagnosing the extractor. Most systems failing this test were never asked for more than a boolean and a clause number, which makes the extraction compliant with a schema that was wrong before any code ran — the reason a taxonomy belongs in the clause list agreed before anyone builds the extractor.

  • The Indemnifying Party, named. Not inferred from which side of the page the clause sits on, and not inherited from the party named in the surrounding article heading.
  • The Indemnified Party, and everyone it reaches. Affiliates, officers, employees, agents and sometimes end customers appear in the beneficiary set, so a single counterparty name understates the obligation.
  • The triggering events, in full. Third-party infringement, breach of confidentiality, personal injury, breach of a data-protection commitment: 4 separate triggers with 4 different likelihoods of ever firing.
  • Control of the defence and the right to settle. Who appoints counsel, who may settle, and whether consent may be withheld. This is the operative mechanic and the field most often empty.
  • Conditions and carve-backs. Notice periods, cooperation duties, and the "except to the extent caused by" sentence that trails the obligation and narrows it, often in the very next line.

5 ways an indemnity loses its owner

Match the rows against your graded labels rather than reasoning about likelihood. 2 of these produce a confidently populated field and are invisible unless somebody reads the source clause; the other 3 leave a hole you can query for.

CauseWhat the record showsWhat the clause looks likeWhat to change
Passive drafting, no named actorIndemnifying Party absent, or filled from the article heading"shall be indemnified and held harmless", actor left to the readerResolve the actor explicitly; where it will not resolve, write "unresolved" rather than a best guess
Mutual indemnity written once with role placeholdersDirection correct for 1 side, reversed for the other"each Party shall indemnify the other", with Indemnifying Party defined as a role, not a nameEmit 2 obligation records from the 1 clause, and store the role-to-party binding on each
Triggers listed by cross-referenceTrigger list short, generic, or repeating the heading"in respect of the matters described in the Schedule", substance 20 pages awayFollow the reference before the field is written; an unresolved pointer is a miss, not a value
Defence and settlement in a separate sub-clauseDefence control empty while the indemnity is populatedThe obligation ends, a new numbered sub-clause begins, the mechanic lives thereExtend the span to the whole indemnity article, then pull fields from inside that span
Carve-backs trailing the obligationDirection right, scope materially too wide"except to the extent arising from the negligence of the Indemnified Party"Treat exclusions as part of the same record, so scope and direction move together
Cause, the observable it leaves in the record, and the change that removes it

Rows 2 and 3 are the expensive ones. Both produce a full-looking field with a plausible name in it, so no completeness check flags them and no reviewer scanning for blanks stops. They surface only when somebody relies on the record, in front of a counterparty.

The sub-clause that was cut away from the obligation it belongs to

An indemnity article is rarely 1 clause. The obligation is stated, notice is required, conduct of the defence is allocated, settlement consent is qualified — 4 units, each under its own number. A segmenter cutting on numbering hands the first to the indemnity extractor and drops the other 3 into the taxonomy's bucket for unclassified text. The extractor then correctly reports that the text it was given holds no defence mechanic.

That puts the defect upstream of the model, which is why prompt edits never move it. The cut is the decision that determines whether later analysis can be right at all: how a contract is cut into clauses before anything reads it. Executed paper is worse again, because appended schedules and spliced signature pages disturb the very numbering the segmenter keys on, the pathology set isolated in extraction that falls apart on the signed conformed copy.

Routing each label from the sample to its own repair

  1. Party absent on both your paper and theirs. Passive drafting. Add a resolution step that reads the clause with the definitions and the Parties clause in scope, and a schema that permits an explicit unresolved value.
  2. Party present and wrong, concentrated on mutual clauses. A records-per-clause problem, not a reading problem. One clause has to be allowed to produce 2 obligations before anything else helps.
  3. Triggers short, direction right. Search the clause for a pointer to a Schedule, an Annex or a defined term. If one is there, retrieval never followed it, and resolving defined terms and where their meanings move is a prerequisite rather than an enhancement.
  4. Defence control empty across most of the sample. Compare the stored span against the document. If the span ends before the sub-clause allocating conduct of the defence, it is segmentation, and re-prompting cannot reach it.
  5. Correct on your template, wrong on theirs. The extractor learned your house conventions. Rebuild the sample so counterparty paper is the majority, then re-grade before changing anything.

A record saying an indemnity is present, without saying who owes it, has turned a document a lawyer could read into a database nobody can act on.

What a corrected indemnity record still leaves open

Getting direction, triggers and defence control right makes the record true. It does not make it a judgement, and it is not yet an artefact anyone can send. 4 things sit outside this repair.

The through-line is that an indemnity record is an operational object rather than a summary: somebody will answer whether a claim is covered from the record, and will not open the contract to check. Building the surface where it is read, corrected and trusted is ordinary internal tools and operations software, and it sits with the rest of contract review, clause risk and redlining in our work with legal teams.

Frequently asked questions

Short answers to the follow-ups this page tends to raise.

Why does contract extraction find the indemnity but get the indemnifying party wrong?

Because finding a clause and attributing it are different problems. Detection matches language patterns, which models handle well. Attribution means resolving a role — "the Indemnifying Party", "such Party", or a passive construction with no actor at all — back to a named entity in the Parties clause, and where the drafting never states the actor the extractor supplies the most plausible name instead of refusing. The result is a populated field that no completeness check will flag.

How should a system store a mutual indemnity?

As 2 obligation records, 1 per direction, generated from the single clause. A mutual indemnity creates an obligation running each way, and a schema storing 1 record per clause forces the extractor to pick a direction, so it will be right for one side and wrong for the other. Each record should carry the role-to-party binding it came from, so a reviewer can see which sentence produced which direction.

Why is the defence and settlement field almost always empty?

Because it usually lives in a separate numbered sub-clause that the segmenter cut off before the extractor saw it. The obligation sits in one sub-clause, notice in the next, conduct of the defence in the one after. If the extraction span is a single numbered unit, the model is being asked about text that genuinely does not contain the mechanic, and it correctly reports nothing. Widen the span to the whole indemnity article before touching the prompt.

What sample size proves an indemnity extractor is working?

10 graded contracts is enough to find a systematic fault and nowhere near enough to state an accuracy figure. 10 will reliably expose direction reversal on mutual clauses, unfollowed cross-references and a truncated clause span, because each affects most documents containing the pattern. A rate you would quote to a partner needs a far larger sample of counterparty paper.

Should an unresolved indemnifying party be left blank or filled with a best guess?

Stored explicitly as unresolved, which is neither blank nor guessed. A blank is indistinguishable from a field nobody asked for, and a guess presents identically to a right answer. An unresolved value can be counted, routed and reported on, which turns the hardest clauses into a queue instead of silent errors spread through the repository.

  • indemnity
  • clause extraction
  • contract review
  • diagnosis
// shipped work

The work behind this page

Builds from our portfolio that this page draws on.

Read next

Working on something in this space?

Tell us where you are in a sentence or two. We'll tell you honestly whether we're the right team, and what a sensible first slice of the work looks like.

Start the conversation