Sam
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
How do you give a fast, shallow voice model the benefit of slow, careful thinking?
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.
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.
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.
There are two obvious designs. Both fall short.
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?
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.
Lateness is only the first of five ways instructions go wrong:
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.
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.
Hears and speaks directly, with no text in between.
Thinks privately before answering. Slower, but sees the whole interview.
Answers narrow questions with a confidence score. Never writes prose.
Less capable than Sol, but faster and cheaper.
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.
| Model | Speed | Sounds natural | Big-picture thinking | Quick yes/no calls | Follows rules exactly |
|---|---|---|---|---|---|
| Sam | |||||
| Sol | |||||
| Jev | |||||
| Luna |
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.
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.
Reads the answer in a tenth of a second.
While the participant answers, Sol finishes updating the conversation map:
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.
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.
The system runs three loops at different speeds. Each does only work it can finish in time for its own clock.
Sam listens and replies. Nothing else ever makes Sam wait.
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.
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:
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.
The conversation map has three parts:
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.
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 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: 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.
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).
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.
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.
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.
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:
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.
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.
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.
Sol sees the big picture but is too slow to know what fits right now. That's Jev's job, plus some simple math.
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.”
Two more questions are asked once per thread, when Sol creates or rewords it, rather than after every answer:
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.
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.
The margin shrinks the longer Sam stays on a thread, so no thread holds the floor forever.
Holds are temporary and never written to the conversation map.
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.
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.
Sent only when Jev's top pick changes.
Sent at most once a minute, when the map changes.
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.
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.
Ground every question in what this participant built and what they bring up.
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?
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?
Open questions like “what were the challenges?” get polished answers. Something specific to react to gets real ones.
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…?
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?
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?
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?
Short reflections that prove Sam heard, check its understanding, and surface what the participant took for granted.
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?
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?
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?
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”?
Bad news is often the most useful part of a closeout, so Sam neither skips past it nor dwells on it.
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?
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?
Two habits that apply to everything Sam says.
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?
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.
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.
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.
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.
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.
Research results are added to the end of the log too. Inserting anything earlier would break the match for everything after it.
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.
| Risk | What prevents it |
|---|---|
| Stale advice | Cues are optional, each replaces the last, and the pick is re-checked after every answer. |
| Made-up facts | Project facts cite the participant's words, and code checks the citation. |
| A broken update | Code rejects the whole edit list; the last good conversation map stays. |
| Sneaky instructions | Fixed note templates; Sol's text is flattened to single lines. |
| Asking again | Ruled-out threads become facts about the participant's vantage, and Sam drops threads they can't answer or decline. |
| Topic ping-pong | The stickiness margin. |
| Hammering a dead end | Stalled threads are held down for 3 minutes. |
| Checklist takeover | Topics are hidden from Sam, and topic threads get no boost. |
| Runaway time or cost | Hard limits: 50 s per Sol update, 90 updates, 3 s per Jev read, 3 lookups, 100 notes. Prompt caching. |
| Leaking the conversation | Only a spoken name and short clue go to web search. |
| A pause or restart | A 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.