# Don't Let the LLM Drive - Ornella Bahidika & Joel Allou, Microsoft

Ornella Bahidika · Joel Allou

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/m24UKZomm7k-dont-let-llm-drive) · [Video](https://www.youtube.com/watch?v=m24UKZomm7k)

## Don't Let the LLM Drive

Ace’s live voice tutor puts lesson progression in a state machine, leaving the model to perform bounded actions while a harness validates results and decides what happens next.

Basic familiarity with LLM applications and application state is helpful; the TypeScript example illustrates who owns a lesson transition.

### The lesson ends halfway through

[0:00](https://www.youtube.com/watch?v=m24UKZomm7k&t=0s)

A multi-step agent completes its demo perfectly. Then a real user arrives, and halfway through the interaction it declares itself finished, skips a state, or loops. For Ace, the live AI voice tutor built by Ornella Bahidika and Joel Allou, that failure would mean losing the structure of a lesson that needs to run from introduction to completion.

![Slide titled “It ended the lesson halfway through.” Two boxes contrast a demo that runs start to finish with production that declares itself done, skips, or loops.](https://ai.engineer/api/talk-essay-media/dbdcc73350a16066da05593de654f00889b1224e17fc69b00da8921fef2c5caa)

The lesson ends halfway through: a clean demo contrasts with production skips and loops.

The tempting repair is to add more instructions: remember the steps, do not skip ahead, do not stop early. Bahidika frames the underlying issue as **control flow**. The model can deliver a good explanation without reliably tracking whether it is on step three of six. Her analogy separates the talent from the director: the model delivers the line; the surrounding harness keeps the production moving through the right sequence.

### Give each step a narrow contract

[0:53](https://www.youtube.com/watch?v=m24UKZomm7k&t=53s)

Ace organizes a lesson as a small **state machine**: `intro → teach → check → grade → advance → wrap`. Each step gives the model one bounded assignment and asks for its result. The harness then validates that result, advances the state, and selects the next assignment. **The model does not determine the current lesson state.**

A minimal TypeScript sketch of that boundary can make the ownership explicit. Here, a `teach` operation returns an explanation; only application code can move the lesson to `check`.

```typescript
type Lesson = {
  state: "teach" | "check";
  topic: string;
  explanation: string | null;
};

type TeachInput = {
  action: "teach";
  topic: string;
};

async function teach(
  lesson: Lesson,
  callModel: (input: TeachInput) => Promise<unknown>
): Promise<Lesson> {
  if (lesson.state !== "teach") {
    throw new Error("Lesson is not ready to teach");
  }

  const result = await callModel({
    action: "teach",
    topic: lesson.topic,
  });

  if (typeof result !== "string" || result.trim() === "") {
    throw new Error("Expected a nonempty explanation");
  }

  return {
    ...lesson,
    explanation: result.trim(),
    state: "check",
  };
}
```

The model supplies content, not a `nextState` field. An invalid response prevents this transition. The string check illustrates the validation boundary; Ace’s actual content-validation rules are not detailed in the talk.

### Smaller assignments enable a smaller model

[1:24](https://www.youtube.com/watch?v=m24UKZomm7k&t=84s)

Allou starts with [**Claude Opus 4.7**](https://www.anthropic.com/news/claude-opus-4-7) as an example of a frontier model people might use for thinking, processing, and everything between. A live tutor has a more specific constraint: it must speak back and forth with students while remaining reliable, affordable, and fast. Handing the entire lesson to a powerful model leaves that model responsible for coordination as well as conversation.

The harness narrows that responsibility by answering three questions before each action:

1. What step is active now?
2. Which steps are allowed to follow it?
3. What concrete input does the model need to perform only the current action?

This confines each model call to the work required at that moment, rather than asking it to reconstruct the lesson’s control logic.

Allou reports that [**Claude Haiku 4.5**](https://www.anthropic.com/news/claude-haiku-4-5), despite having less reasoning capability than the larger model, meets Ace’s expected performance with this harness. He reports savings in money, time, and latency, but supplies no measurements or controlled tutoring comparison. The demonstration then turns to a recorded lesson, with harness logs displayed on the right side.

### Control the operations around the conversation

[3:35](https://www.youtube.com/watch?v=m24UKZomm7k&t=215s)

The narrated recording shows that the harness covers more than the order of spoken exchanges. Allou identifies several operational responsibilities:

- **Section instructions:** Give the model the specific material to speak about and the action to perform.
- **Whiteboard drawing:** Handle the drawing actions that accompany the lesson.
- **Queue clearing:** Include explicit steps for clearing the queue.
- **Lesson completion:** Define how the lesson ends instead of leaving completion to an improvised model decision.

The completed screen offers `Practice: Grammar Foundations` and `Back to Home`, with the developer console alongside it. The individual operations come from Allou’s narration; the console text in this frame is too small to read in detail.

![Lesson completion screen with a “Practice: Grammar Foundations” button, a “Back to Home” button, and a developer console on the right. Below, the slide reads “The model proposes. The harness decides.”](https://ai.engineer/api/talk-essay-media/e02df91d196844c5d1c9c3a2bf70600c3660c45afbc4a59a0e8eba70aaf2214c)

The demo reaches “Lesson done. Practice next.” with console logs alongside.

New scenarios become additions to the state machine and lesson logic. The model’s local job remains the same: receive an action-specific input and return that action’s output. Reliability therefore depends on the harness covering the situations the lesson can encounter, including operational steps that are easy to overlook when focusing only on the conversation.

### The model proposes; the harness decides

[4:21](https://www.youtube.com/watch?v=m24UKZomm7k&t=261s)

That division becomes consequential at three decision points in Ace:

| Decision | Harness responsibility |
| --- | --- |
| Is the lesson done? | Own the completion decision. |
| Did the student get it right? | Own the decision about correctness and intended learning. |
| What comes next? | Select the next step. |

A model output can be a proposal without becoming an authoritative state change. These decisions determine whether the tutor continues teaching, evaluates progress, or ends the lesson.

Allou says the questions and actions within these categories are engineered outside the model. His description of the model as not having to think concerns this bounded responsibility: it receives an input and produces an output, while the application owns the surrounding decisions. The talk does not specify the grading rules or how Ace establishes that a student has learned the material, so the architectural boundary is clearer than the assessment implementation.

### Move unreliable control flow into code

[5:02](https://www.youtube.com/watch?v=m24UKZomm7k&t=302s)

The same division can apply to coding agents, applications, runbooks, and onboarding flows. Allou’s diagnostic is qualitative: if reliable completion feels like a coin flip, examine how many workflow decisions the model owns. Move those decisions into the surrounding application and give the model simpler inputs for bounded actions.

The ending returns to the voice tutor with a useful self-correction: let the model talk, but do not let it drive. A model can explain, converse, and propose useful outputs while the harness remains responsible for where the lesson is, whether a result is acceptable, and what happens next.

## Resources

- [Introducing Claude Opus 4.7](https://www.anthropic.com/news/claude-opus-4-7) — Anthropic's release announcement for the larger model used as the talk's comparison point.
- [Introducing Claude Haiku 4.5](https://www.anthropic.com/news/claude-haiku-4-5) — Release announcement covering Haiku 4.5's capabilities, launch pricing, and evaluation methodology.
- [Building effective agents](https://www.anthropic.com/engineering/building-effective-agents) — Practical workflow patterns, including predefined control paths and programmatic checks between model calls.

## Slides

### Don't Let the LLM Drive

Ornella Bahidika and Joel Allou introduce Ace, a live AI voice tutor built to run complete lessons reliably with the LLM not in charge.

[0:00](https://www.youtube.com/watch?v=m24UKZomm7k&t=0s) [Title slide introducing harness engineering and the presenters.](https://assets.ai.engineer/sites/aiecode2025/sha256/1bec492062dcceeba71186ecbe4e19ff4bc91adeac0d898460a933e836c5f64a.webp)

ACE

HARNESS ENGINEERING

Don't Let the LLM Drive.

Ornella Bahidika
PRODUCT

Joel Allou
ENGINEERING

aceactprep.com

Interface text:
Ornella Bahidika
Joel Allou

### It ended the lesson halfway through

A multi-step agent can run cleanly in a demo, then declare a lesson done halfway through, skip a state, or loop when a real user tries it.

[0:11](https://www.youtube.com/watch?v=m24UKZomm7k&t=11s) [A clean demo is contrasted with production behavior that ends early, skips or loops.](https://assets.ai.engineer/sites/aiecode2025/sha256/5de9911800237529ec3aa7da936287929091713955a49ed6682dd6993640df77.webp)

THE FELT PROBLEM

It ended the lesson halfway through.

In the demo
Runs clean, start to finish.

In production
Declares itself done. Skips. Loops.

Demos hide it. Real users find it.

Interface text:
Ornella Bahidika
Joel Allou

### Just prompt it harder

The illustrated reliability curve rises, then plateaus as prompt rules increase. The speaker frames agent reliability as a control problem.

[0:28](https://www.youtube.com/watch?v=m24UKZomm7k&t=28s) [A graph depicts reliability plateauing as prompt rules increase.](https://assets.ai.engineer/sites/aiecode2025/sha256/4f4d4929bcad18c5e83eb4050b0fa3db5aee12b726786ff77bf8e91a12ff42db.webp)

THE TRAP

Just prompt it harder.

reliability
plateau
more prompt rules →

Reliability was never a prompting problem.

Interface text:
Ornella Bahidika
Joel Allou

### The model is the talent; the harness is the director

The harness directs the workflow, so the model can deliver language without having to remember which step it is on.

[0:37](https://www.youtube.com/watch?v=m24UKZomm7k&t=37s) [The slide compares the model to talent and the harness to a director.](https://assets.ai.engineer/sites/aiecode2025/sha256/3c19df3c2500333a66d5279f1b2169a6cc346c5d4cad0c06ed306a2a8e9fee11.webp)

THE REFRAME

The model is the talent. The harness is the director.

Brilliant at delivering a line. Terrible at remembering it's on step three of six. So we stopped asking it to.

Interface text:
Ornella Bahidika
Joel Allou

### A lesson is a small state machine

The harness moves a lesson through six states, validates the model’s responses, and loops back to teaching if mastery is not reached. The model returns language; the harness decides what happens next.

[0:54](https://www.youtube.com/watch?v=m24UKZomm7k&t=54s) [A lesson progresses through intro, teach, check, grade, advance and wrap, with a loop back to teaching if mastery is not reached.](https://assets.ai.engineer/sites/aiecode2025/sha256/07394533d45efdb8f132223dc777002f15a5e5acbad0ca22fb17c9bab9b256f4.webp)

THE ARCHITECTURE

A lesson is a small state machine. The harness drives it.

intro → teach → check → grade → advance → wrap

advance [illegible] loops back to teach if not mastered

HARNESS → MODEL
Narrow contract: do this one thing, return that.

MODEL → HARNESS
Returns language. Never decides where we are.

Interface text:
Ornella Bahidika
Joel Allou

### Grammar lesson begins

The grammar lesson opens with a whiteboard agenda while the console logs section and draw signals. The presenter says the section directs what the model should discuss and do.

[3:22](https://www.youtube.com/watch?v=m24UKZomm7k&t=202s) [A tutoring interface introduces parts of speech, sentences, and verb tense on a whiteboard.](https://assets.ai.engineer/sites/aiecode2025/sha256/96dafa590cb2700377baf86558a0c3ef263ddb72d3510d7827188d039d6cc912.webp)

Today: Parts of Speech → Sentences → Verb Tense

Hey Jordan, welcome back.

Today we're building your grammar toolkit for the A C T. We'll start with the eight parts of speech—the building blocks of

Interface text:
DAY 2 OF 150 - ENGLISH
English Foundations: Parts of Speech, Sentence Structure, and Verb Tense
CH. GRAMMAR FOUND... 0/6
TEACHING
END
100%
Type a question
Pax is speaking...

Console
harnes
Default levels
5 Issues: 1 2 2
2 hidden
use-livekit-lesson.ts:378
[harness] signal → section
{type: 'section', kind: 'intro', title: 'Grammar Foundations: Parts of Speech, Sentence Structure, and Verb Tense'}
use-livekit-lesson.ts:378
[harness] signal → draw
{type: 'draw', op: 'add_text', params: [illegible]}
cmd i to turn on code suggestions. Don't show again

### Request to end the lesson

The learner asks to end the lesson, and the tutor checks whether something is wrong. Console logs show section, drawing, and queue-clearing signals as the lesson runs.

[3:34](https://www.youtube.com/watch?v=m24UKZomm7k&t=214s) [The learner asks to end the lesson; the tutor asks whether something is wrong.](https://assets.ai.engineer/sites/aiecode2025/sha256/7663dd567a5c14b2dcc30f6e9cace851cf42f900c6e78c680ec73fd30e0beda6.webp)

Today: Parts of Speech → Sentences → Verb Tense

The A C T tests grammar through reading passages. You'll identify errors i[illegible]

Hey Jordan, welcome back.

Today we're building your grammar toolkit for the A C T. We'll start with the eight parts of speech—the building blocks of every sentence.

I'm ready to end the lesson.

Got it. Before we wrap, let me ask: are you feeling okay, or is there something about the lesson that isn't working

Interface text:
DAY 2 OF 150 - ENGLISH
English Foundations: Parts of Speech, Sentence Structure, and Verb Tense
CH. GRAMMAR FOUND... 0/6
TEACHING
END
Console
harness
Default levels
5 Issues: 1 2 2 2 hidden
use-livekit-lesson.ts:378
[harness] signal → section
{type: 'section', kind: 'intro', title: 'Grammar Foundations: Parts of Speech, Sentence Structure, and Verb Tense'}
use-livekit-lesson.ts:378
[harness] signal → draw
{type: 'draw', op: 'add_text', params: {…}}
use-livekit-lesson.ts:378
[harness] signal → clear_queue
{type: 'clear_queue'}
use-livekit-lesson.ts:378
[harness] signal → draw
{type: 'draw', op: 'add_text', params: {…}}
use-livekit-lesson.ts:378
[harness] signal → clear_queue
{type: 'clear_queue'}
[illegible] to turn on code suggestions. Don't show again
100%
Type a question
Pax is speaking...

### Tutor wraps up the lesson

The tutor closes the lesson after the learner asks to stop. The console shows queue-clearing and end signals; the presenter describes these as steps incorporated into the lesson’s state machine.

[3:43](https://www.youtube.com/watch?v=m24UKZomm7k&t=223s) [The tutor gives a closing response while an end signal appears in the console.](https://assets.ai.engineer/sites/aiecode2025/sha256/8d473f108b5f7b20e6eeb3a9df343588b6221db0e7259e300295873c904e5de3.webp)

Today: Parts of Speech → Sentences → Verb Tense

The A C T tests grammar through reading passages. You’ll identify errors i[illegible]

Hey Jordan, welcome back.

Today we’re building your grammar toolkit for the A C T. We’ll start with the eight parts of speech—the building blocks of every sentence.

I’m ready to end the lesson.

Got it. Before we wrap, let me ask: are you feeling okay, or is there something about the lesson that isn’t working

Yes.

from the milky. We can wrap the lesson.

No problem, Jordan. You’ve got a solid foundation to build on with grammar—keep working through those parts of speech and sentence structure, and you’ll spot errors on the A C T much faster.

Interface text:
DAY 2 OF 150 - ENGLISH
English Foundations: Parts of Speech, Sentence Structure, and Verb Tense
CH. GRAMMAR FOUND... 0/6
LIVE
END
Type a question
Listening
100%
Console
harnes
Default levels
5 Issues: 1 2 2 3 hidden
use-livekit-lesson.ts:378
[harness] signal → section
{type: 'section', kind: 'intro', title: 'Grammar Foundations: Parts of Speech, Sentence Structure, and Verb Tense'}
[harness] signal → draw
{type: 'draw', op: 'add_text', params: {…}}
[harness] signal → clear_queue
{type: 'clear_queue'}
[harness] signal → draw
{type: 'draw', op: 'add_text', params: {…}}
[harness] signal → clear_queue
{type: 'clear_queue'}
[harness] signal → end {type: 'end'}
cmd i to turn on code suggestions. Don’t show again

### Lesson complete

The lesson ends with a choice to start grammar practice or return home. Practice must be completed to mark the day complete and unlock the next; the speaker says the harness makes the final decision.

[3:59](https://www.youtube.com/watch?v=m24UKZomm7k&t=239s) [A session-complete screen offers grammar practice or a return home.](https://assets.ai.engineer/sites/aiecode2025/sha256/9e7e089eee584bdd9f37a5029c2dfee8bb43bc26c322ad1be39d04d1f109f1d4.webp)

Lesson done. Practice next.

Finish the practice questions to mark today complete and unlock the next day. Skipping practice means this day stays open.

→ PRACTICE: GRAMMAR FOUNDATIONS
BACK TO HOME
HOW WAS THE LESSON? SEND FEEDBACK

Interface text:
Session complete
Console
harnes
Default levels
5 Issues: [illegible] 4 hidden
use-livekit-lesson.ts:378
[harness] signal → section
{type: 'section', kind: 'intro', title: 'Grammar Foundations: Parts of Speech, Sentence Structure, and Verb Tense'}
use-livekit-lesson.ts:378
[harness] signal → draw
{type: 'draw', op: 'add_text', params: [illegible]}
use-livekit-lesson.ts:378
[harness] signal → clear_queue
{type: 'clear_queue'}
use-livekit-lesson.ts:378
[harness] signal → draw
{type: 'draw', op: 'add_text', params: [illegible]}
use-livekit-lesson.ts:378
[harness] signal → clear_queue
{type: 'clear_queue'}
use-livekit-lesson.ts:378
[harness] signal → end {type: 'end'}
[illegible] to turn on code suggestions. Don't show again
Stop Screen Recording
Options
Capture
N

### What the LLM should never own

In Ace, the model proposes actions, but the harness decides when a lesson is done, whether the student got it right, and what comes next. These decisions are engineered outside the model.

[4:25](https://www.youtube.com/watch?v=m24UKZomm7k&t=265s) [A slide crosses out three questions about lesson completion, correctness, and what comes next, saying they belong to code.](https://assets.ai.engineer/sites/aiecode2025/sha256/9363a4ade347e4b634ba67939f7b9e3bdd26d42e1ee5e1189a92db48b04475ec.webp)

WHAT THE LLM SHOULD NEVER OWN

01 Is the lesson done?
02 Did they get it right?
03 What comes next?

These belong to code. In any flow agent.

Interface text:
Ornella Bahidika
Joel Allou

### Take control flow out of the model

When agent reliability is a coin flip, move decisions outside the model and give it simpler inputs. The rule applies to coding agents, ops runbooks and onboarding flows.

[5:19](https://www.youtube.com/watch?v=m24UKZomm7k&t=319s) [An orange slide advises taking control flow out of the model when reliability is a coin flip.](https://assets.ai.engineer/sites/aiecode2025/sha256/ec4ba76da2ce85cc9df13a20a079236db38d6c8f316634aefc697f91d5373bbc.webp)

THE RULE

When reliability is a coin flip, take control flow out of the model.

coding agents · ops runbooks · onboarding flows

Let it talk. Don't let it drive.

Interface text:
Ornella Bahidika
Joel Allou

### Let the model talk. You keep the wheel.

When reliability is a coin flip, move decisions into the surrounding control flow and give the model an easy input to produce an output.

[5:58](https://www.youtube.com/watch?v=m24UKZomm7k&t=358s) [Closing slide with the message “Let the model talk. You keep the wheel,” presenter names, and two small video tiles.](https://assets.ai.engineer/sites/aiecode2025/sha256/e4a1272100bb93396317399e2a329b6def3ba810d4eccbe3f93ecf21d6add92e.webp)

Let the model talk. You keep the wheel.

ACE

Ornella Bahidika
PRODUCT

Joel Allou
ENGINEERING

aceactprep.com

Interface text:
Ornella Bahidika
Joel Allou

## Full transcript

[0:00](https://www.youtube.com/watch?v=m24UKZomm7k&t=0s) Hi, I'm Ornella, that's Joel. And we built Ace, a live AI voice tutor that runs a full lesson, start to finish reliably. The trick is LLM is not in charge.

[0:13](https://www.youtube.com/watch?v=m24UKZomm7k&t=13s) If you have shipped a multi-step agent, you know this moment. It nails the demo, then a real user gets in, and halfway through, the agent decide it's done, or skip a state or even loops.

[0:26](https://www.youtube.com/watch?v=m24UKZomm7k&t=26s) The demo never show you that. And the first fix everyone reaches for is prompt it harder, add more rules. But reliability was never a prompting problem. It's a control problem.

[0:41](https://www.youtube.com/watch?v=m24UKZomm7k&t=41s) Think of it this way. The model is the talent, and the harness is the director. The model is brilliant at delivering a line, but it's really terrible at remembering if it's on step three of six.

[0:53](https://www.youtube.com/watch?v=m24UKZomm7k&t=53s) So we stop asking it to. A lesson is a small state machine with intro, teach, check, grade, advance, and wrap. Each steps hands the model a narrow contract. Do this one thing, return it.

[1:10](https://www.youtube.com/watch?v=m24UKZomm7k&t=70s) The harness validates what comes back, advance the state, and decide what's next. The model never decide where we are. That's the design. Joel is going to show you the harness thing.

[1:24](https://www.youtube.com/watch?v=m24UKZomm7k&t=84s) Yeah. So when we think about the frontier models of today, let's take for example, um, Opus 4.7 Claude from Anthropic, you see that oftentimes people leverage the model for essentially everything.

[1:40](https://www.youtube.com/watch?v=m24UKZomm7k&t=100s) For the thinking, for the processing, right? And for everything in between. While that can be good, it's not always effective in situation like ours where we are building a live AI tutor that is speaking back and forth with students, right?

[1:57](https://www.youtube.com/watch?v=m24UKZomm7k&t=117s) For something like this, we have a need to actually build something that is reliable, something that is cost-effective, and something that is fast, right? So this is where the idea of leveraging the concept of harness engineering has come in, where instead of having a model that is really intelligent sort of go through everything for us, we will

[2:21](https://www.youtube.com/watch?v=m24UKZomm7k&t=141s) build all of these steps that are needed and provide only the input required for the model to execute a specific scenario. So when we were building Ace, we actually thought very deeply about state machines, right?

[2:35](https://www.youtube.com/watch?v=m24UKZomm7k&t=155s) What is the step right now? And what is the possible steps that could come after? And within each of the steps, what are concrete things that we can provide to the model so that it is confined to that specific action, it is confined to that specific step at that particular moment and only execute what needs to be

[2:55](https://www.youtube.com/watch?v=m24UKZomm7k&t=175s) done. So by doing this, instead of having a very heavy model like a four point seven, we're actually able to rely on something like a Haiku four point five, which is a much smaller model, doesn't have as much reasoning capabilities, but because of the harnessing around it, is still able to perform at the level in which we

[3:14](https://www.youtube.com/watch?v=m24UKZomm7k&t=194s) expect, saving money, saving time, and saving latency. So let's go ahead and play this recording, which will show us logs, um, about a particular lesson. So as you can see in this video, especially on the right side, we see logs on all of the different harnessing that are happening, right?

[3:35](https://www.youtube.com/watch?v=m24UKZomm7k&t=215s) So for example, we see that there is harnessing for a section which provides input to the model about exactly what to speak about, what to do. We have harnessing about drawing on the whiteboard.

[3:48](https://www.youtube.com/watch?v=m24UKZomm7k&t=228s) We have harnessing that deals with clearing the queue. We have steps to how to end the lesson and everything in between, right? So everything that would allow us to actually build the lesson in a way that is reliable, even if there's a new scenario that comes in, we try to incorporate that in our state machine.

[4:09](https://www.youtube.com/watch?v=m24UKZomm7k&t=249s) We try to incorporate that with- within the lesson, right? So again, the model, all it worries about is given an input, it knows which action to take, and it provides the output of that action, right?

[4:21](https://www.youtube.com/watch?v=m24UKZomm7k&t=261s) And so the model never really, um, um, has to think. It proposes, but ultimately it is the harness that decides. And so for his-- Ace specifically, there are three things that we wanted to think about.

[4:33](https://www.youtube.com/watch?v=m24UKZomm7k&t=273s) Like when is the lesson done is one, right? Did the student actually get it right? Like, did they actually learn in the way they were supposed to? And what comes next, right?

[4:41](https://www.youtube.com/watch?v=m24UKZomm7k&t=281s) And so everything that comes within those three categories, all of the different questions, all of the different actions that the models needs to take, we have engineered that outside of the model, right?

[4:52](https://www.youtube.com/watch?v=m24UKZomm7k&t=292s) So again, it's an input. The model receives it and gives us an output, right? And so this is very, very important, and we have found this to be very remarkable, right?

[5:02](https://www.youtube.com/watch?v=m24UKZomm7k&t=302s) So again, the, the... This is applicable to really everything, right? It's applicable to something like Ace that is a voice model. It's applicable to coding agents, to apps, runbooks.

[5:15](https://www.youtube.com/watch?v=m24UKZomm7k&t=315s) Um, it's applicable to onboarding flows, right? The same rule applies, right? We want to find a way to not let the model think, but building abstractions around it. So a good way to, to remember on whether you should use this abstraction is essentially to think about the reliability of your agent, right?

[5:35](https://www.youtube.com/watch?v=m24UKZomm7k&t=335s) If it's somewhat of a coin flip, then you wanna take the control flow out of the model. You want the model to not make as many decisions as it could, and instead build those decisions around the model and simply feed an easy input so that the model can easily produce an output, right?

[5:53](https://www.youtube.com/watch?v=m24UKZomm7k&t=353s) So don't let the model talk, right? Or actually let it talk, but don't let it drive. So we're Joel and Ornella. This is Ace, and if you have any questions, please let us know.

[6:05](https://www.youtube.com/watch?v=m24UKZomm7k&t=365s) Thank you.

[6:06](https://www.youtube.com/watch?v=m24UKZomm7k&t=366s) Thank you.
