# What Did We Agree, a call debrief where every line is backed by the exact words said

A sanitised reference implementation. Drop it into Claude Code, point it at your own
call recordings, adapt the headings. Generic on purpose, with no business specifics
and no real calls.

## The problem

After a good call you remember the gist, not the detail. Who promised what, which
price, which date, what was left hanging. Notes taken during the call are partial,
and memory quietly rewrites things by the next morning. An AI summary can be worse,
because it sounds right and can still be wrong. A figure gets stitched together from
a garbled sentence. Your own "what if we did this" gets written down as the other
side's commitment. A polite "yeah, yeah" gets logged as a yes.

## The idea

Record the call and transcribe it on your own computer with a local speech model,
so the audio never leaves the machine and costs nothing. Then pull out every
promise, price, date and open question, and make each one carry the exact words
from the transcript, who said them and roughly where in the call. Then hand those
claims to a separate checker whose only job is to try to kill each one against the
transcript. Only what survives goes into the debrief.

```
recording ──> [local transcription] ──> transcript
                                            │
                                            v
                  [pull out claims, each with its exact quote and speaker]
                                            │
                                            v
                  [a separate checker tries to kill every claim]
                                            │
                                            v
      one page. Agreed. Promised by you. Promised by them. Still open.
```

## Minimal reference implementation

```python
# what_did_we_agree.py, reference only. Transcription runs on your own machine.
import whisper   # pip install openai-whisper

def transcribe(path, model_name="turbo"):
    """Local speech to text. Nothing is uploaded. Use a large model for real
    calls, because a small one garbles names and numbers."""
    model = whisper.load_model(model_name)
    return model.transcribe(path)["text"]
```

```text
EVERY CLAIM CARRIES FIVE THINGS
    Claim      what was said, agreed or promised
    Quote      the exact words from the transcript
    Speaker    who said them
    Where      roughly how far into the call
    Verdict    set by the checker, never by whoever found the claim

THE CHECKER'S VERDICTS
    CONFIRMED       the quote is real, the speaker is right, the meaning is not stretched
    OVERSTATED      the substance is real but a detail was invented, so keep the
                    substance and drop the detail
    MISATTRIBUTED   it was your own words or your own what if, not theirs
    UNGROUNDED      it cannot be found in the transcript, so it goes

THE CHECKER'S BRIEF
    Try to kill every claim. Watch for numbers stitched from unclear speech,
    agreement read into politeness, and your own framing echoed back as theirs.
    No quote, no claim.
```

## Why it works

- **No quote, no claim.** Every line in the debrief can be traced back to words
  someone actually said, so nothing rests on a model's impression of the call.
- **The finder is never the judge.** A separate checker with a brief to disprove
  catches what the first reader wanted to hear.
- **Four verdicts, not two.** Overstated and misattributed are the common failures,
  and they deserve different fixes. Keep the real substance, drop the invented
  detail, and put your own ideas back where they belong.
- **The audio stays at home.** Local transcription means no upload and no per minute
  fee, and a large local model is good enough to trust on names and figures.
- **Sized to the call.** A quick first read within about twenty minutes covers most
  calls. The full check with more than one checker is kept for a dispute, or for
  anything that will go to the other side in writing.

## Adapt it

- Make recording your standard and say so at the start of the call.
- Change the headings to your own trade. A builder might want materials, dates on
  site and who pays for what.
- If a plan or a quote existed before the call, compare the call against it. What was
  scoped, what was agreed and what crept in are three different lists.

Built for my own calls with customers and suppliers, and this is the generalised
version. Take it, run it on your next call, tell me what it catches.