Agents make dozens of small decisions per task: which tool, which skill, are these arguments grounded, is it time to ask the user, is the task done. Here is where a fast decision model fits in an agent loop, a gate that stops an agent from guessing, what skill selection gained in TypeSafe's test, and real-time control at ten decisions a second.
Key takeaways
- Most of an agent's decisions are rote; let a decision model make those and save the LLM for the hard ones.
- Good spots: model routing, tool and skill selection, argument checks before a tool runs, guardrails, and 'is it done?' checks.
- A before-tool-call gate with two narrow questions can make an agent ask instead of guessing.
- Selecting skills with a decision model cut wrong skill loads from 16.8% to 7.3% in TypeSafe's test of 182 skills.
- Prefer workflows (code-defined paths with smart nodes) when you can map the decision tree; use agents when you can't.
Try it with your agent
Paste this into your coding agent (works best on an agent you are building):
In our agent, add a hook that runs before every tool call. It sends the conversation and the proposed call to a decision model with narrow questions: are the argument values grounded in what the user said? is it premature to act before clarifying? is this tool appropriate for the request? If any check fails, hand the turn back to the agent with specific feedback instead of failing. Log the probabilities, and add a test where the user omits a required detail.
Transcript
Intro
Agents are where language models make the most decisions per minute: which tool, which file, ask or act, done or not. Most of those decisions are small. That's where a fast decision model belongs.
Plus, not versus
TypeSafe's founder is clear that this isn't a rivalry. The future, he says, is not going to be System One models versus LLMs. It's System One models plus code. And for agents, plus the LLM.
Where it fits
AWS built Strands Decider for exactly this. Its README lists the spots: route each task to the right model. Pick the next tool. Check a tool call's arguments before it runs. Triage, guardrails, cheap evaluations. And hybrid agents, where the LLM makes the hard decisions and a decider makes the rote ones.
A gate before tools
Here's the Strands example. The agent has a weather tool, and an eager system prompt. A user asks: what's the weather? No city. The agent guesses one and calls the tool. But before the call runs, a hook asks the decider two narrow questions. Are the argument values grounded in facts the user actually gave? Is it premature to call this tool before clarifying? A few lines of Python, and the agent goes back and asks which city.
Pick the right skill
Skill selection is another big one. Agents usually stuff every skill description into the prompt and hope. TypeSafe tested an agent with a hundred eighty two skills. On its own, it loaded the wrong skill for sixteen point eight percent of requests that had a matching skill. With a decider ranking skills first, then rechecking the top three with their full text, that fell to seven point three percent. Needless loads fell from nine point eight to four.
Ask the decider
You can also hand the agent the decision model as a tool. Developer IndyDevDan gave his coding agent an ask Jev tool for yes or no and classification questions about files. The agent stopped reading whole files into its expensive context just to answer a simple question. His words: we delegated a QA task for file reading outside of my expensive language model to Jev.
Real time
And speed opens a new kind of agent: one that acts in real time. TypeSafe's demo plays Doom at ten decisions a second, which costs about seven dollars an hour. Opper's Pac-Man benchmark gives each decision a two second deadline: answer late, and a simple backup rule moves instead.
Workflow or agent?
Finally, step back. Anthropic separates workflows, where code defines the paths, from agents, where the LLM decides its own steps. A decision model makes workflows far more capable, because every node can now judge meaning. So before you build an agent, ask: could this be a workflow with smart nodes? If you can map the decision tree, it should be.
Quick check
Quick check. Your agent sometimes calls a payment tool with an amount the user never mentioned. What's the best fix with a decision model?
Try it
Try it. Have your agent add a decision model gate to its own tool calls.
Recap
So: decision models go inside agents, not instead of them. Route, pick tools and skills, check arguments, decide when it's done. Gate risky calls and guide the agent back. And when you can map the decision tree, build a workflow with smart nodes. That's module five's first half. Next: turning judgments into data.