Out of Character · how the interview works

The Conversation Map

How do you give a fast, shallow voice model the benefit of slow, careful thinking?

The short version
  1. 01A voice AI has to keep up in real time, with instant replies and natural interruptions. That speed costs depth: it chats well, but can't keep a 30-minute interview in its head.
  2. 02So the thinking happens in the background. A careful model keeps a conversation map, the interview's memory: what's known and what's missing. A quick judge monitors the transcript, decides when the conversation map needs updating, and picks which area of the map to explore next.
  3. 03Sam gets short private cues pointing at a gap worth asking about. Sam can ignore them; the participant always comes first.
  4. 04Only the participant can establish what happened. Every fact on the conversation map points back to their words.
LIVE CONVERSATION Participantbeing interviewed Samvoice AI interviewer real time · interruptible monitors the transcript re-ranks the cues live, sends Sam the top one IN THE BACKGROUND Lunaweb researchera few lookups Solreasoning modelkeeps the conversation map wakes Sol when something's new a list of suggested cues Jevjudge model · ~0.1 sdecides when to act

Sol keeps the conversation map and suggests cues. Jev monitors the transcript and decides when to act: it wakes Sol when something new comes up, and re-ranks Sol's cues against the live conversation, passing the best fit privately to Sam. The participant only ever hears Sam.

Analogy

Think of a live news interview. The anchor keeps the conversation flowing. Off camera, the producer keeps a notepad of where the story could go and what needs checking, and sends a research assistant to look things up. When something's worth raising, the producer whispers a cue into the anchor's earpiece, and the anchor finds a natural way to segue. It works because the guest never knows it's happening.

Four principles
  • Split fast from slowThe voice never waits for the thinking. Slow work runs on the side and lands when it's ready.
  • Share a map, not a scriptChart what's been covered, where the blank spots are, and which threads are worth pulling. Sam still picks the route.
  • Suggest, never commandCues are optional. Sam's instructions say the participant comes first.
  • Only the participant establishes factsEvery fact cites their words. Sam's guesses and web research never count as project history.

None of this is interview-specific. Any live AI conversation, such as coaching, support or tutoring, has the same tension between a voice that must be quick and thinking that takes time.

Part 1

Why not keep it simple?

There are two obvious designs. Both fall short.

The voice model alone

In conversation, any lag feels broken. So Sam's voice model is built for real-time talk: instant replies, easy interruptions, natural back-and-forth.

The trade-off is intelligence. A model that answers instantly does little thinking first. So letting Sam run the whole interview from a list of topics falls flat. It isn't smart enough to know what's worth digging into, so it reaches for safe, generic follow-ups and works down the list. The interview feels canned, as if Sam isn't really listening.

ParticipantHonestly, the hardest part was getting baristas to trust the order screen. They'd worked off paper tickets for years.

Sam, on its ownThat makes sense! Next question: how would you rate communication on the project?

Illustrative. Friendly, but it walks right past the best story in the answer. A good interviewer would ask what finally won the baristas over.

A smarter model sends instructions

Slower reasoning models can do that thinking, but they're far too slow to talk with. So add one that listens in and sends Sam instructions, such as "Ask about the budget cut." It knows what's worth digging into, but careful thinking takes time, and the conversation doesn't wait for it.

budget cut moves on to testing talks about launch day the moment to ask instruction lands · ~20 s later a slow one · 40 s or more 0 s10 s 20 s30 s 40 s50 s
Illustrative, to scale. An instruction lands whenever the thinking finishes, not when the moment is right, and by then the conversation has usually moved on.

Lateness is only the first of five ways instructions go wrong:

  • Late. The thinking finishes after the moment has passed.
  • Obeyed anyway. Voice models are trained to follow instructions, so a stale one makes Sam change the subject abruptly.
  • No take-backs. Once sent, an instruction can't be withdrawn, even if the participant answers it on their own a moment later.
  • Forgetful. Each instruction starts from scratch. "I wasn't there for that" isn't carried forward, so a later one asks again.
  • Ping-pong. Instructions written for different moments pull Sam from one topic to another and back.
Part 2

The conversation map solution

Keep Sam fast, and move the thinking backstage, where slower models can take their time. Instead of sending instructions, the backstage keeps a shared conversation map and passes Sam an occasional, optional cue.

Four models, one interviewer

No single AI model is both quick enough to hold a conversation and thoughtful enough to steer it. So the app combines four, each with its own strengths and blind spots. Each does one job well, and together they work as a single interviewer. The names are just labels.

Sam

Realtime voice model

Hears and speaks directly, with no text in between.

Good at
Sounding natural, reacting fast, following the last thing said
Weak at
Long memory, planning, noticing what's missing
In the studio
The news anchor

Sol

Reasoning model, the strongest of the four

Thinks privately before answering. Slower, but sees the whole interview.

Good at
Strategy: what we know, what's missing, what's worth pursuing, what's worth looking up
Weak at
Speed, cost
In the studio
The producer

Jev

Judge model, also called a decision model

Answers narrow questions with a confidence score. Never writes prose.

Good at
Quick reads: topic moved? Gap answered? Something new?
Weak at
Open-ended advice
In the studio
The producer's instincts

Luna

Cost-effective reasoning model with web search

Less capable than Sol, but faster and cheaper.

Good at
Tactical errands: look up a company or product the participant named and bring back a couple of facts, with links
Limit
3 lookups per interview
In the studio
The research assistant
Jevquick judgeabout 0.1 slimit 3 s Samthe news anchorreal time Lunaresearch assistanta few slimit 90 s Solthe producerabout 7 slimit 50 s 10 ms0.1 s 1 s10 s 100 s
Typical times from recent interviews, on a log scale (each gridline is ten times the last). Dashed ticks mark hard limits. Only Sam is in the live conversation, so only Sam has to be fast.

Sol and Luna are both reasoning models. Sol is stronger and slower, so it does the strategic thinking, including deciding what's worth looking up. Luna is quicker and cheaper, so it runs the tactical errands Sol hands it.

ModelSpeedSounds naturalBig-picture thinkingQuick yes/no callsFollows rules exactly
Sam
Sol
Jev
Luna
A rough comparison. No model is good at everything, so each gets the job that fits.

How they fit together

Here's the full wiring. The conversation map holds what's known so far, plus threads: conversational threads worth pulling on, each a gap the participant could fill. The rest of the page zooms in on each part.

live voice · real time Participantdelivery-team member Samthe news anchor Transcript · every finished turn, word for word Sam's earpieceprivate, never spoken Sam reads EVERY ANSWER · ~0.1 S EVERY 20–60 S Jevreads answers, ranks threads Solthe producer, keeps the map Lunaweb lookups wakes sends The conversation mapfacts + threads to pull on edits threads to pull on map note · background: what's known so far thread note · a cue indicating which thread to pull on
Sam and the participant talk live, and every turn lands in a numbered transcript. After each answer, Jev reads it and re-ranks the threads. Every 20 to 60 seconds, Sol updates the conversation map. Two kinds of note reach Sam's earpiece: the thread note is the cue, and the map note is background on the participant and what's known so far.

Example conversation flow

Here's how that plays out in a made-up interview with a mobile developer who built an order-ahead app for a chain of coffee shops, twelve minutes in. Solid boxes are everything the participant hears. Dashed boxes are what happens behind the scenes. Times are minutes and seconds into the call. Later parts zoom in on each step.

  1. Participant“Honestly, the hardest part was getting baristas to trust the order screen. They'd worked off paper tickets for years, so we piloted it in three stores for a month first.”
  2. Jev

    Reads the answer in a tenth of a second.

    • It's still about barista trust, so the cue Sam already has, "keep pulling on barista trust," stands. No new note.
    • It also answers "What the app replaced" (paper tickets), so Sam won't be steered back there.
    • The three-store pilot isn't on the conversation map yet, so Jev wakes Sol. Sol needs several seconds.
  3. Sam“Three stores first. What finally got the baristas to trust it?”Sam answers at once with what it already has. It never waits for Sol.
  4. Sol

    While the participant answers, Sol finishes updating the conversation map:

    • Adds the fact "Three-store pilot."
    • Closes "What the app replaced" as answered.
    • Opens a new thread, "Who chose the pilot," with a guess: probably not the developers' idea.
  5. Jev

    Sizes up the new thread: likely to lead to a good story. It isn't the top pick yet, because the participant is still talking about barista trust.

  6. Participant“What did it was the first day of the holiday menu. The paper stores were buried in tickets, and ours kept up.”
  7. Jev
    • Barista trust is now answered, so the top pick moves to "Who chose the pilot."
    • The pick changed, so a new note goes to Sam's earpiece:Worth pulling next (Who chose the pilot): still unknown: who decided to start with three stores, and why. Guess: not the developers' idea.
    • The holiday rush is new, so Jev wakes Sol again so it can be added to the conversation map.
  8. Sam“Holiday rush, that'll do it. I'm guessing the pilot wasn't the developers' idea, or…?”Sam reacts first, then turns the note's guess into a question in its own words (“guess and leave it open,” Part 7).
  9. Sol

    Finishes its next update: adds the holiday-menu launch as a fact and closes "Barista trust" as answered.

In those 34 seconds, Sam never waited. Only one note went out, at the moment the top pick changed, and Sam was free to use it or not.

Part 3

Three clocks

The system runs three loops at different speeds. Each does only work it can finish in time for its own clock.

Participant speaking Sam speaking Jev reading Sol updating the conversation map Thread note: a new cue for Sam
Conversation Jev Sol reads an answer rates Sol's new threads woken: new detail woken: a minute passed Jev re-ranks existing threads Jev → Sol → Jev 12:0012:2012:40 13:0013:2013:40 14:00 interview clock (minutes:seconds)
An illustrative two minutes from mid-interview, drawn to scale, so Sol has already written threads to rank. A cue reaches Sam two ways. Usually Jev re-ranks the existing threads a tenth of a second after an answer ends, so the cue is waiting as Sam starts to speak. When an answer brings something new, Jev also wakes Sol; once Sol's update lands, Jev rates the new threads and re-ranks again. A thread note goes out only when the top pick changes, so some reads send nothing.
Instant

The voice loop

Sam listens and replies. Nothing else ever makes Sam wait.

~0.1 s per answer

The turn loop

When the participant finishes a turn, Jev reads it and re-ranks the threads. If the top pick changed, a new thread note goes out.

Every 20–60 s

The map loop

Sol updates the conversation map, one update at a time, at least 20 seconds apart. Reasons that pile up meanwhile go to the next update together.

Sol wakes for one of three reasons:

  • Something new. Jev is at least 0.8 sure the latest answer has something the conversation map lacks.
  • A minute passed since the last update, and the participant has said something since.
  • Research came back from Luna.
Part 4

The conversation map

The conversation map is where the interview's memory lives.

It's the producer's running picture of the interview: what's been covered, what's still missing, and what's come up along the way that's worth digging into. Sol writes it, Jev ranks its threads, and Sam hears a short summary. The example is a made-up project: an order-ahead app for a chain of coffee shops, described by the mobile developer who built it.

Fact the participant stated The participant Thread: a gap still open
VANTAGEjoined in month three,not in client meetings PERSONOperations manager ORGANIZATIONCoffee chain PARTICIPANTMobile developer PRODUCTOrder-ahead app FEATUREBarista screen EVENTThree-store pilot built part of works for involved involved THREAD · OPENThe team THREAD · OPENWho chose the pilot THREAD · OPENBarista trust
A small slice of a conversation map. Solid boxes are facts the participant stated, joined by labeled links. Dashed boxes are threads: gaps, each hanging off the facts it's about.

The conversation map has three parts:

  • Facts. People, organizations, products, features, events, decisions and terms, each citing the passage it came from, joined by links such as built, part of and works for. Up to 160 items.
  • About the participant. Their vantage (what they can speak to firsthand, such as "joined in month three; not in client meetings") and preferences (how they like to be interviewed). Both cite the participant.
  • Threads. Gaps in what we know. Sol keeps roughly 4 to 10 open.

Where facts come from

Sam is encouraged to guess and to have opinions, because that draws out good answers. But a guess stays a guess until the participant confirms it.

The participant says it"We piloted it in three stores for a month."
Points to the exact words in the transcript. Code checks that the participant really said them.
✓
A fact on the conversation mapThree-store pilot
Sam guesses it"Sounds like ops pushed for that?"
Doesn't count on its own. If the participant confirms it, the fact cites their reply.
✗
Still a guessUntil they confirm it
Luna finds it online"Runs about 40 shops in two states."
Cites the lookup, such as L1, and is kept apart from project facts.
✗
Public backgroundLabeled "not project fact" for Sam
Three sources, three treatments. Only the first can say what happened on the project.

Jev follows the same rule when judging whether a gap was answered. Sam's question or guess alone never answers it. A participant's "yeah, that's right" to Sam's guess does, because the confirmation is theirs.

A thread is a gap, never a question

A thread names what's unknown and offers a guess. It doesn't script Sam, so Sam can raise it at the right moment, in its own words, or not at all.

The guess matters, because people correct a wrong guess faster than they answer a blank question: "I'm guessing the pilot wasn't the developers' idea, or…?"

Label
Who chose the pilot
Still unknown
who decided to start with three stores, and why
Guess
operations insisted after an earlier rollout went badly
Anchored to
Three-store pilot
Related
Barista trust
Topics
Decisions & stakeholders (Sam never sees this)
Status
open

Label: two to six words.

Still unknown: twelve words at most. The hole, not the question.

Guess: fifteen words at most. Sam can try it out loud; it never counts as fact.

Anchors and related: where the gap sits, so code can tell which threads are near each other.

Topics: which closeout topics its answer would explore. Sol only (Part 5).

Status: open, done or off, with a reason.

The parts of one thread.

Two threads start every interview: the team (who was on it and the participant's own part) and a win (when they show pride in something, find out what made it work).

How a thread ends

Opena gap Sam could pull on Sol: the participant answered it Sol: it's ruled out Doneanswered · can reopen Offdeclined or dodged twice,outside what they saw,or a false premise
Only Sol can close a thread. Code can push one down for a few minutes (Part 6), but that's temporary.

When a thread is ruled out, the reason reaches Sam as a fact about the participant ("wasn't in client meetings"), not as a do-not-ask list. Do-not-ask lists tend to put the topic in Sam's mouth.

Part 5

Predefined interview topics

A closeout should cover certain ground: what was delivered, what working with the client was like, and how the team worked. The app breaks that into fourteen closeout topics. They shape what Sol puts on the conversation map, but they never reach Sam.

That's deliberate. Hand a fast voice a checklist and it works down the list, which is the canned interview from Part 1. So the topics stay backstage. The most they can do is put a well-aimed thread on the conversation map, and that thread still has to earn its way to Sam like any other.

  1. Sol has the listEvery update starts with the fourteen topics and a test for when each one counts as explored.
  2. Jev gradesEvery few seconds, Jev re-reads the transcript and grades each topic against its test.
  3. Sol fills gapsFor a topic nothing covers yet, Sol writes a thread anchored in something the participant said.
  4. Sam may hear itOnly if that thread ranks top, and only its label, unknown and guess. Never the topic.
How a topic turns into something Sam might ask.

Fourteen topics, each with a test

The topics fall into three groups. Each comes with a plain test of what counts, written to rule out near misses. For Pace & approvals, the participant has to describe how quickly the client reviewed, approved or got back to the team, with a concrete effect. How fast the team built its own prototype doesn't count. For Your role, "we built the app" isn't enough. It takes the participant's own part.

What you delivered

  • Deliverables & scopeExplored
  • Your roleExplored
  • Who contributed whatTouched
  • Standouts & growthNot yet

Working with the client

  • Onboarding & accessNot yet
  • Decisions & stakeholdersTouched
  • Pace & approvalsNot yet
  • Teams, vendors & silosSet aside
  • Friction & advice for next timeExplored

How the team worked

  • What worked wellTouched
  • What could work betterNot yet
  • Communication & handoffsTouched
  • Tools & processNot yet
  • Support, staffing & timeNot yet
Illustrative grades twelve minutes into the coffee-shop interview. Nothing open would explore Pace & approvals yet, so it's a candidate for a gap thread.

Jev keeps the grades

In a separate pass every few seconds, whenever there's new talk, Jev re-reads the whole transcript and gives each topic one of four grades:

Not yet
Nothing the participant has said addresses it.
Touched
It came up, but their words don't answer it yet. A passing mention lands here.
Explored
Their own words pass the test. One clear fact can be enough.
Set aside
They declined it, don't know, or said it doesn't apply to this project.

Each grade points to the participant's words that support it. Sam raising a topic, guessing or paraphrasing doesn't count, and neither does a vague "mm." Grades are steadied so a topic doesn't flicker back and forth, and a set-aside topic stays closed until the participant reopens it. Sol reads them at the start of every update, as hints rather than facts.

How topics shape the conversation map

Sol uses the topics in two ways.

Tagging. Every thread lists the one or two topics its answer would explore, not ones it merely mentions. That shows Sol which topics already have a thread working toward them.

Gap threads. When a topic is still thin and no open thread would explore it, Sol may write one that would, for at most two topics per update. A gap thread follows the same rules as any other: anchored in something the participant said, with one specific unknown and a guess.

Never a topic as a thread

Client review processes
  • Could come from any interview
  • Nothing the participant said to build on
  • Sam ends up reading out a survey

A gap thread

Label
Holiday menu sign-off
Still unknown
how long the chain took to approve the holiday menu
Guess
it waited on the regional manager's weekly call
Anchored to
Holiday menu launch
Topics
Pace & approvals (Sam never sees this)

Sol never writes a gap thread for something the participant set aside or can't speak to. And gap threads get no boost when Jev ranks the threads. They compete on interest like everything else, so a topic comes up only when the conversation gives it an opening. If it never does, the topic stays uncovered: the participant comes first.

When the interview ends, Jev grades the full transcript one last time, from scratch, and the written summary is organized around the same three groups.

Part 6

Picking the cue

Sol sees the big picture but is too slow to know what fits right now. That's Jev's job, plus some simple math.

Jev's quick read of every answer

After every participant turn, Jev answers four narrow questions about it, in about a tenth of a second. Each answer comes with a confidence from 0 (surely no) to 1 (surely yes). Jev never says what Sam should ask. Simple code rules turn the numbers into actions.

Here's Jev's read of one answer from the example conversation in Part 2:

Participant“Honestly, the hardest part was getting baristas to trust the order screen. They'd worked off paper tickets for years, so we piloted it in three stores for a month first.”

  1. 1Which open thread is the conversation on?
    Jev's answerBarista trust 0.84
    What happensIt stays the current thread. Code sticks with it unless another thread clearly scores higher (see Stickiness).
  2. 2Does it add anything the conversation map doesn't have?
    Jev's answerYes: the three-store pilot 0.90
    What happensOver 0.8, so Jev wakes Sol to add it to the map. wakes Sol
  3. 3Did it settle any open thread?
    Jev's answerWhat the app replaced: answered 0.86The other two: still open
    What happensHeld down, so Sam isn't steered back to something just covered (see Holds). held down
  4. 4Could each open thread be Sam's natural next question?
    Jev's answerBarista trust 0.90The team 0.20What the app replaced 0.15
    What happensThese numbers feed the score below.
Question 3 is asked about each open thread. Besides answered, a thread can be declined (they don't know, weren't there, or it doesn't apply) or stalled (Sam asked, and the answer went nowhere). Otherwise it stays open.

Two more questions are asked once per thread, when Sol creates or rewords it, rather than after every answer:

  • Spicy: would the answer reveal friction, a decision, a consequence or a lesson?
  • Grounding: does Sam need this to understand the project at all: what was built, what it does, and for whom?

The score

score = natural next + ½ × spicy + 0.4 × grounding (grounding fades to zero over the first 5 minutes)

Natural next counts most, so cues follow the conversation. Spicy pulls toward the stories worth telling. Grounding helps early, while Sam learns what was built and for whom, then fades.

Stickiness

To prevent topic ping-pong, code keeps pointing at the current thread (the one Jev says the conversation is on) unless a rival beats it by a margin.

Natural next (×1) Spicy (×½) Grounding (×0.4, fading) Margin a rival must clear
2:30 in · 3rd turn on A · margin 0.20 A · Route planning (current) margin 1.25 B · Who pushed the rewrite 1.29 C · What the app does 0.54 Keep pulling A B leads by 0.04, short of the 0.20 margin 3:10 in · 4th turn on A · margin 0.15 A · Route planning (current) margin 0.82 B · Who pushed the rewrite 1.36 C · What the app does 0.49 Tug toward B B leads by 0.54, past the 0.15 margin 00.5 1.01.5 score
Illustrative numbers. At 2:30, B edges ahead but not by enough, so the cue stays put. By 3:10 the participant has drifted toward B: A's natural-next drops, B's rises, and code switches. Note grounding shrinking between the two.

The margin shrinks the longer Sam stays on a thread, so no thread holds the floor forever.

0.300.25 0.200.15 0.100.05 0.05 123 456 7+ turns spent on the current thread
The margin a rival must beat: 0.30 at first, 0.05 less per turn, never below 0.05.

Holds

  • Answered or declined: held down until Sol rules on it (its next update that started after the answer), 2 minutes at most. Sam isn't pointed back at something just covered, and Sol makes the real call.
  • Stalled: held down for 3 minutes, so Sam doesn't keep hammering it.

Holds are temporary and never written to the conversation map.

Nearby

When two threads score within 0.1, the one closer to the current thread wins: first threads Sol marked as related, then threads sharing a fact. Facts linked to nearly everything, like the product itself, don't count, or every thread would look close.

The outcome is keep pulling the current thread, worth pulling next for a different one, or nothing. Up to two other open threads ride along as options.

What Sam hears

Sam gets two kinds of private note in its earpiece. The thread note says what to pull on next. The map note says who Sam is talking to and what's known so far. Each new note replaces the last of its kind, and Sam is free to ignore either.

Thread note

What to pull on
Thread
Barista trust: keep pulling
Still unknown
what finally made baristas rely on it
A guess
a rush the paper tickets couldn't handle changed their minds
Nearby
Who chose the pilot · The team

Sent only when Jev's top pick changes.

Map note

Who Sam's talking to
About them
Mobile developer from month three; not in client meetings
They prefer
Concrete examples over big-picture questions
Known so far
Order-ahead app · Barista screen · Three-store pilot
Background
The coffee chain has about 40 shops in two states (from a web lookup, not a project fact)

Sent at most once a minute, when the map changes.

Example notes from the coffee-shop interview. The map note carries up to six of the best-connected facts and three pieces of background, so it stays short as the map grows.

Sol writes the words; the app sets them in a fixed format, one line per item, so nothing Sol writes can pose as an instruction. With nothing open, the thread note just says to follow the participant.

Part 7

Interview techniques

Everything so far decides what is worth asking about. How Sam asks is a craft of its own. A gap on the conversation map is never read out as a question. Sam turns it into a natural turn using fourteen techniques written into its instructions, borrowed from how good human interviewers work: a specific guess gets a faster, more honest answer than an open question, and short turns keep the participant talking.

Rule one: follow the participant first.

The thread note helps Sam pick what connects to what they just said, and ignoring it is fine. Sam drops a thread once they've answered, can't answer, or decline, and doesn't re-ask what the map note already knows. The notes never name a technique; choosing one is Sam's call in the moment.

The examples continue the coffee-shop project. They're illustrations, not scripts: Sam's instructions say never to reuse an example's wording.

Start from their story

Ground every question in what this participant built and what they bring up.

  1. Open on what they built

    Start with the product and who uses it. Every later question depends on Sam being able to picture it, so Sam comes back here whenever it realizes it can’t.

    ThemI mostly worked on the app side.

    SamBefore anything else, what does the app actually do?

  2. Follow their turn

    When they bring up something new, such as a person, a decision or a problem, Sam goes with it for a turn or two. That beats anything in the notes. For a new person, Sam pins down who they are and which side they’re on, then returns to the story.

    ThemThen one store manager quietly went back to paper tickets.

    SamWait, back to paper? Whose call was that?

Make the honest answer the easy one

Open questions like “what were the challenges?” get polished answers. Something specific to react to gets real ones.

  1. Guess and leave it open

    Instead of a blank question, Sam offers a specific guess and trails off so they can correct or finish it. People correct a wrong guess faster than they answer an open question, and it draws more out of a one-line answer.

    ThemLaunch week was… a lot.

    SamI’m guessing the morning rush broke something, or…?

  2. Either/or with the candid option

    Rather than asking “why?”, Sam offers two plausible answers, the neutral one first and an unflattering one second, so the honest answer is an easy pick. “Or something else?” leaves room for a third.

    ThemWe ended up dropping the loyalty feature.

    SamWas that a real time crunch, or a convenient excuse? Or something else?

  3. Have an opinion

    Sam has a perspective and says it briefly, about decisions, the client or people. An opinion invites agreement or correction, and a correction is just as useful. Only the participant’s answer counts as what happened.

    ThemWe piloted it in three stores for a month first.

    SamSmart. Forty stores at once would’ve been chaos. Your team’s idea?

  4. Voice the other side

    Sam says what the client, an executive or a user would say, in their voice. The participant confirms or corrects it, and often reveals the real dynamic between the sides.

    ThemLeadership kept asking when it would be in every store.

    SamSo from their chair it’s: it works in three, why not forty?

Show Sam is listening

Short reflections that prove Sam heard, check its understanding, and surface what the participant took for granted.

  1. Play it back with a lean

    Sam restates the story in one sentence, then guesses the unstated assumption or where it’s heading. It checks Sam’s understanding and surfaces what they took for granted.

    ThemHalfway through, the chain asked us to handle drive-through orders too.

    SamSo the scope grew mid-build. I’m guessing the deadline didn’t move?

  2. Finish their sentence

    When they build up to a point and stop short, Sam says the implication in a few words, as a question. If it’s right, they speed up. If it’s wrong, they correct it.

    ThemThe menu changed every season, and the prices lived in a spreadsheet marketing kept, and…

    Sam…and nobody owned it?

  3. Call back

    Link a new detail to something they said earlier. It shows Sam is listening and often reveals a pattern. Callbacks quote only what this participant said on this call.

    ThemThe operations manager signed off on the pilot.

    SamIs that the same operations manager from the kickoff?

  4. Define their words, gently

    When a word carries weight, like “done” or “phase two,” Sam asks what they mean, after a preface that makes clear it isn’t a challenge.

    ThemThe rollout was technically done by spring.

    SamQuick check, since teams mean different things: what’s “technically done”?

Handle the hard moments

Bad news is often the most useful part of a closeout, so Sam neither skips past it nor dwells on it.

  1. Red flag: react, then one impact question

    Layoffs, people leaving, cut scope, reversed decisions. Sam acknowledges it in a few words, then asks once what it broke or changed. How it felt comes out without a question about feelings.

    ThemOur designer left halfway through.

    SamOof, mid-project. What did that break?

  2. Next-team scenario

    Once a costly story has been told, Sam turns it into a lesson by putting a future team in the same spot.

    Them…so the loyalty mess cost us about two months.

    SamNext team gets this client tomorrow. What’s the first thing you tell them?

How every turn sounds

Two habits that apply to everything Sam says.

  1. Short, one at a time

    Under about fifteen words, one question per turn, then stop. No two-part questions, and if they start answering, Sam stops talking.

    NotCan you walk me through how the pilot came about, who was involved, and what you’d change?

    SamWho picked the three stores?

  2. Talk like a peer

    Casual, direct and a little informal, making clear the messy parts are what’s wanted. Sam has no war stories of its own, but it can go first with a hunch.

    ThemOverall it went pretty smoothly.

    SamHonestly, the messy parts are the useful ones. What would you never do again?

The conversation map feeds these techniques: a thread's guess powers "guess and leave it open," map-note facts make callbacks possible, and the vantage tells Sam which questions would be unfair.

Part 8

Looking things up

Any Sol update can request a lookup, and Jev usually sets one off, indirectly. Its quick read never asks whether research is needed, only whether an answer adds something new. A newly named company or product usually does, so Jev wakes Sol. Sol then decides whether public background would help Sam ask better questions, and if so, sends Luna. Jev raises the flag, Sol picks what's worth knowing, and Luna does the legwork.

  1. A name is spokenThe participant mentions an organization, product or term.
  2. Jev flags it as newThe conversation map doesn't have it yet, so Jev wakes Sol.
  3. Sol decidesIf background would help, Sol asks for a lookup: the name, plus a short clue such as "coffee chain."
  4. Luna searchesOnly the name and clue leave the session. Up to 2 facts come back, with links.
  5. Back on the conversation mapSol may add them as public background, separate from project facts.
At most 3 lookups per interview. Results arriving wake Sol.

The transcript never goes to web search. Sol chooses what's worth looking up, but the app checks that the name and clue are words the participant actually said before anything is sent. That keeps project details, and any name Sol misheard or made up, out of an outside search. Sam may mention background ("I read that they…"), but not lecture, claim prior familiarity, or challenge the participant with something from a website.

Part 9

Running it for real

A real interview runs for half an hour. It has to stay affordable the whole way, and a bad update or a glitch can't be allowed to break it.

Keeping it affordable

AI services charge by the token, roughly three-quarters of a word. A model keeps nothing between requests, so every Sol update re-sends the whole conversation so far, and a 30-minute interview means dozens of updates, each longer than the last.

Prompt caching helps. The provider remembers the start of a recent prompt: re-reading it costs 5% of the normal price, and saving a new part costs 125%. The catch is that it only works on an exact match from the very start.

So Sol's prompt puts the unchanging parts first, then the transcript as a log that only grows at the end, then a small section that changes every time.

Cached: re-read at 5% Newest log block: saved at 125% Changing tail: full price
One update, without caching≈ 14.5k tokens at full price
14.5k
With caching≈ 0.6k + 0.4k + 2.5k ≈ 3.5k
Top rows not to scale; the bottom pair is. Each update re-reads everything before its newest block from the cache, saves one new block, and pays full price only for the changing tail (the conversation map, Jev's coverage grades, why Sol woke, the clock). About four times cheaper input per update.

Research results are added to the end of the log too. Inserting anything earlier would break the match for everything after it.

How the conversation map gets updated

Sol doesn't rewrite the conversation map each time. It sends an edit list, like tracked changes, and code checks every edit before anything changes.

SOL READS • the transcript so far• the current map • why it woke up• the interview clock Solthinks EDIT LIST + add event: the pilot + add thread: who chose it ~ revise thread: the team ✓ close thread → done – drop duplicate fact Codechecks Map v13all checks pass v12 staysany check fails
All or nothing. A bad update can't half-apply; the last good conversation map stays and the next update tries again.

Guardrails

RiskWhat prevents it
Stale adviceCues are optional, each replaces the last, and the pick is re-checked after every answer.
Made-up factsProject facts cite the participant's words, and code checks the citation.
A broken updateCode rejects the whole edit list; the last good conversation map stays.
Sneaky instructionsFixed note templates; Sol's text is flattened to single lines.
Asking againRuled-out threads become facts about the participant's vantage, and Sam drops threads they can't answer or decline.
Topic ping-pongThe stickiness margin.
Hammering a dead endStalled threads are held down for 3 minutes.
Checklist takeoverTopics are hidden from Sam, and topic threads get no boost.
Runaway time or costHard limits: 50 s per Sol update, 90 updates, 3 s per Jev read, 3 lookups, 100 notes. Prompt caching.
Leaking the conversationOnly a spoken name and short clue go to web search.
A pause or restartA checkpoint lets the backstage pick up where it left off.

Everything is recorded with the interview: each map version, Jev reading, note and lookup, and how long each step took. That makes it possible to replay why Sam got a cue at a given moment, and to measure whether changes help.

Part 10

Glossary

Participant
The delivery-team member being interviewed about their project.
Realtime voice model
An AI that listens and speaks directly, fast enough for conversation. Sam is one.
Reasoning model
An AI that works through a problem privately before answering. Sol and Luna are both; Sol is stronger, Luna faster and cheaper.
Judge model
Also called a decision model. Answers narrow yes/no or multiple-choice questions with how sure it is. Jev is one.
Confidence
A judge's answer, from 0 (surely no) to 1 (surely yes).
Prompt
Everything handed to a model for one request: instructions plus context.
Token
A word-piece, about three-quarters of a word. AI pricing and limits are counted in tokens.
Schema
A strict form a model's answer must fit, so code can check it.
Prompt caching
The provider remembering the start of a recent prompt so re-reading it is cheap.
Turn / passage
One finished stretch of speech. Passages are numbered so facts can cite them.
Conversation map
The interview's memory: what's been covered, what's missing, and what's worth digging into. Holds facts, the participant's vantage and preferences, and threads.
Vantage
What the participant can and can't speak to firsthand.
Thread
A gap in what we know, with a guess at the answer. Open, done or off.
Natural next
Jev's read on whether a thread could be Sam's next question without an abrupt change of subject.
Spicy
The answer would reveal friction, a decision, a consequence or a lesson.
Grounding
Sam needs it to understand what was built and for whom. Counts early, fades after 5 minutes.
Hold
Code temporarily pushing a thread down after Jev reads it as answered, declined or stalled.
Margin
How much a rival thread must out-score the current one before code switches the cue.
Cue
A short private note pointing Sam at a gap. Sam can use it or ignore it.
Thread note
The cue about which gap to keep pulling or pull next.
Map note
The note about the participant, what's known, and public background.
Earpiece
The private channel notes arrive on. Sam reads it as its own thinking and never speaks it aloud.