Separating the model, the orchestrator and the tool executor
The model proposes, the orchestrator decides, the executor acts: three separate roles.

An agent that can send mail, write to a database or call an API is holding a loaded gun, and the first thing to know is where the trigger is. The model does not pull it. What a language model produces when it wants to act is text — a request other software must read and carry out. Separating the three responsibilities — the model that proposes, the orchestrator that decides, the tool executor that acts — is the central design decision of an agentic system.
Collapse them and two questions become unanswerable: which part authorised this action, and which part may be trusted with which data. Kept apart, both answers are structural, not a matter of the model behaving well.
The three roles
The model produces a request. Anthropic is explicit that a tool call is something the model expresses, not something it does: “it will include a tool use block in the API response if it plans to invoke a tool” (line 118). It holds no credentials and causes no side effect.
The orchestrator owns control flow. It runs the loop, reads the request, calls the executor, appends the result and decides whether to continue. Anthropic reduces an agent to “just LLMs using tools based on environmental feedback in a loop” (line 81); OpenAI’s guide gives that loop a body: “agents are started using the Runner.run() method, which loops over the LLM until either” a final answer or a response with no tool call (lines 353–354).
The tool executor performs the side effect — the function that sends the message or writes the row, with its own credentials and permissions. CaMeL describes the ordinary arrangement plainly: models “generate text in a specific format which is interpreted by the LLM runtime as a tool call. The runtime then runs the tool and returns the result as part of the conversation” (lines 1909–1910).
The boundary is a request, not an action
The decision to act arrives as data in an API response, not as an executed command. The gap between “the model asked” and “the thing happened” is where a system enforces its rules — validate arguments, check permissions, require approval or refuse. Whatever it refuses never happens. A design that lets the model’s text become the action has no such place. The L3 sheet generated text versus executed actions owns that distinction; here the question is narrower — who holds the decision to proceed, and who holds the ability.
Control flow versus data flow
The separation earns its cost by moving control flow out of the model. CaMeL states why: “data and control flow are inherently intertwined and it is hard to explicitly separate the two in generality. However, in an agentic setting with explicit tools and data sources it becomes possible” (lines 1876–1878). The split goes to an extreme: a “CaMeL interpreter: an orchestrator interpreting the code written by the Privileged LLM, propagating capabilities, and enforcing security policies” (lines 367–369), while the quarantined model “has no tool access” (line 418). The system “explicitly extracts the control and data flows from the (trusted) query; therefore, the untrusted data retrieved by the LLM can never impact the program flow” (lines 11–12), and “There is explicit isolation between the models to ensure that data can’t influence the original user query execution plan” (lines 440–441). The rule: the model may read untrusted data, but not decide what runs next.
Where the boundary sits: workflow or agent
Anthropic splits “Workflows are systems where LLMs and tools are orchestrated through predefined code paths” (line 18) from agents, which “dynamically direct their own processes and tool usage” (line 19). In both the executor stays separate; the difference is who owns the next step. That seat itself can be a model: in orchestrator-workers “a central LLM dynamically breaks down tasks, delegates them to worker LLMs, and synthesizes their results” (line 66), and OpenAI’s manager pattern has a model that can “orchestrate a network of specialized agents seamlessly through tool calls” (lines 438–439). The separation survives because the orchestrator — model or code — still decides; it does not hold the tool’s credentials.
What the separation does not buy
- It needs explicit tools and data sources. CaMeL’s caveat is that the split “becomes possible” only in an agentic setting with explicit tools, not in one context holding everything.
- It is necessary, not sufficient. Even CaMeL, with model and executor held apart by design, does not reach zero: with no security policies it “stops almost all of the attacks” but leaves “two injection tasks” that “are successful” (lines 869–870).
- It costs. “The autonomous nature of agents means higher costs, and the potential for compounding errors” (line 84), and more components “can introduce additional complexity and overhead” (OpenAI guide, line 393).
Level and prerequisites. L4 — an architectural sheet: the reader must decide which component owns control flow and which owns credentials and side effects. Prerequisites: the L1 sheets on how a model generates text, the L2 sheets on context and structured output, and the L3 sheets generated text versus executed actions and tool calling: schema, call and result.
Where to go next
- Automation & AI — the macro-area this sheet belongs to.
- Applications — the node this sheet sits in.
References
- Anthropic — Building effective agents — workflows versus agents, the orchestrator-workers pattern, the agent as a loop over tools, the tool-use block, and the cost of autonomy.
- OpenAI — A practical guide to building agents — the run loop, the manager pattern, and the cost of more components.
- Debenedetti et al. — Defeating Prompt Injections by Design (CaMeL) — the explicit control/data-flow separation between a privileged and a quarantined model, and its measured limits.