Once an agent has tools available, a design question arrives immediately: for any given step, should the model decide which tool to call and when, or should that decision be pre-scripted so it happens the same way every single time? Both are legitimate choices, and a well-built agentic system typically contains plenty of both — the skill is knowing which one a particular step calls for.
Two invocation modes
Deterministic invocation means the call is pre-scripted: the same tool, or the same fixed set of tools, fires every time a given step is reached, regardless of what the model concludes. Non-deterministic invocation means the model itself decides, at that moment, which tool (if any) to call, based on its read of the current situation — it might call one tool, several, or none, and the choice can differ from one run to the next even given similar inputs.
A concrete illustration makes the contrast vivid. In one real production system we cover later in this series, a sentiment-analysis agent pre-fetches from three fixed data sources — a news feed, a social-media platform, and a forum — on every single run, unconditionally; the model's only judgment call is what sentiment score to assign to what comes back. A sibling agent in the same system, tasked with macro and news analysis, instead chooses for itself, turn by turn, which subset of five available data tools to call, in what order, looping until its own reasoning decides it has gathered enough.
The rule of thumb
The practical guidance is not "prefer determinism" or "prefer flexibility" as a blanket rule — it's to match the invocation mode to how much judgment the step genuinely requires, and how costly a wrong judgment would be. A step where the right action is always the same, or where getting it wrong is expensive and hard to detect, is a strong candidate for deterministic invocation: pin it down, and don't let model variance introduce risk into a step that never needed flexibility in the first place. A step where the right action genuinely depends on context that only becomes clear at run time is a strong candidate for leaving to the model's own non-deterministic judgment, because pre-scripting it would mean guessing in advance at a decision that's better made with the benefit of that turn's specific context.
This distinction resurfaces constantly once you start looking for it: it's the same underlying idea behind the difference between a command (deterministic, always the same action) and an agent action (non-deterministic, model-inferred), and it's the same idea behind human-approval gates, where the decision to interrupt for a human is itself usually pinned deterministic even though everything the human is reviewing was produced non-deterministically.
Questions to bring to your team
- Which of your workflows would you never let an agent decide on its own?
- Where has too much rigidity, rather than too much autonomy, been the real bottleneck?