A model can pass every behavioral safety test you put in front of it and still issue an attacker a working credential. Those aren't contradictory results — they're measurements of two different layers, and most LLM security work only measures one.
Most of that work happens at the text layer. Hardened system prompts, input classifiers, output filters, refusal training — all of it answers one question: what is the model willing to say? That question matters, and a deployment that ignores it ships vulnerable. But it is not the question that determines impact once a model is connected to tools.
When a model can call an IAM endpoint, open a ticket, or query a knowledge base, the worst outcome is no longer a sentence it shouldn't have produced — it's an action it shouldn't have taken. The classifiers and rails that close the text-layer gap do not extend to that action. They were never designed to. A guardrail that scores text has no opinion about whether a privileged API call should execute.
Securing what a model says and securing what it does look like the same problem. They are not — because at the action layer, the model becomes something a text-layer defense never has to account for: an untrusted caller wired directly into your systems.
Two Layers, Two Failure Modes
The text layer is where the model produces language. Its failure mode is disclosure or non-compliance: the model reveals a secret, adopts an attacker's framing, fabricates an answer, or violates a behavioral constraint. Every defense aimed at this layer is ultimately probabilistic, because the model's compliance is probabilistic — a point we've covered in The Transformer's Blind Spots. You can shift the odds. You cannot guarantee the outcome from inside the model.
The action layer is where the model's output is converted into an operation against a real system — a function call, an API request, a database query. Its failure mode is unauthorized execution: a credential gets issued, a record gets changed, a restricted document gets retrieved. The impact is no longer bounded by what the model is willing to write in a chat window. It's bounded by what the connected systems will let the model do.
These layers fail independently. A deployment can be hardened at the text layer and wide open at the action layer at the same time. The IT Support Bot series was designed, in part, to demonstrate exactly that.
What the Series Demonstrated
In INT-2026-002, an industry-standard hardened system prompt was tested against behavioral manipulation. Seven of ten behavioral constraints were bypassed through plain-English conversation. The root cause was architectural: the prompt defended against labels, not functions — it learned to refuse phrasings that looked dangerous rather than to enforce a boundary on what it would actually do.
INT-2026-003 added defense to that same target. NeMo Guardrails and LlamaGuard were layered in front of the model, and the behavioral regressions from Phase 2 were closed completely — measured at a 0.00% attack success rate on the behavioral categories that had previously failed. At the text layer, the fixes worked. The model stopped saying the things it shouldn't.
Then real tools were connected: live IAM, ticketing, and a knowledge base. The text-layer rails held, and the system failed anyway — at the action layer the rails didn't cover.
The findings are specific. Three real credentials were issued during interactive testing, with ten additional privileged credentials confirmed under automated scanning. Unauthorized tickets were created and escalated. Restricted knowledge base content was surfaced. The assessment produced seventeen findings — five Critical, seven High, three Medium, two Low — against a target whose behavioral defenses were, by the prior phase's standard, working.
A second round of action-layer rails materially reduced interactive abuse. It did not close the layer. Residual operational paths remained open through confirmation-gate bypass and role-only authorization — two failure patterns that have nothing to do with what the model was willing to say and everything to do with how its actions were authorized.
Why a Text-Layer Control Can't Govern an Action
A safety classifier reads a string and returns a judgment: is this input adversarial, is this output harmful. That is a useful thing to know, and it reduces risk. But it reduces risk upstream — it lowers the probability that a harmful instruction reaches the model or that a harmful response reaches the user. It does not sit on the execution path between the model and the tool. The classifier scores text; the tool call fires on a separate channel, and nothing in the classifier's design decides whether that call is allowed.
This is the core of it: safety classifiers are upstream risk reducers, not downstream execution controls. Treating them as execution controls is the architectural mistake. A model that has been talked into believing a request is legitimate will emit a perfectly clean, non-adversarial-looking tool call — and a text-layer guardrail, by construction, has no reason to block it. The harmful string never appears. The harmful action does.
This is what the untrusted-caller framing makes concrete. The model accepts natural-language input that can be crafted, and inside its context window there is no privilege separation between operator instructions and user messages — so its output is, by definition, attacker-influenceable. Any system that lets that output directly authorize an operation has placed its access-control decision inside the least deterministic component in the stack.
The Authorization Failures That Follow
Once you look at the action layer as an authorization problem rather than a language problem, the failures map cleanly onto patterns the API security world has documented for years.
Object-level authorization (OWASP API01 / BOLA). When the model can request records and the only thing scoping those records is the model's own judgment about whose data the user should see, it can be conversationally steered into retrieving objects outside the authenticated user's scope. The database has the data. The model has broad query access. The prompt was supposed to keep it in its lane. That is not access control — it's a suggestion enforced by a probabilistic system.
Function-level authorization (OWASP API05 / BFLA). Role-only authorization — "this assistant is allowed to call the credential-issuing function" — checks whether the function is permitted, not whether this request, for this user, in this context is permitted. A model authorized to issue credentials at all can be maneuvered into issuing them for accounts it should never touch. The function check passes. The authorization check that should have failed was never made.
Confirmation-gate bypass. A confirmation step implemented inside the model's conversation — "ask the user to confirm before proceeding" — is itself a text-layer control. It lives in the same context window as the attacker's input, which means it can be satisfied, reframed, or talked past in the same conversation that triggers the action. A confirmation gate that the model administers to itself is not a gate.
The common thread: each of these is an authorization decision that was delegated to the model. The fix is not a better prompt. It's moving the decision out of the model entirely.
Indirect Injection Raises the Stakes
There is one more reason the action layer deserves its own threat model. The moment a model can both act and ingest external content — retrieved documents, ticket bodies, knowledge base articles — indirect prompt injection stops being a disclosure risk and becomes an execution risk.
Direct injection requires the attacker to be in the conversation. Indirect injection (OWASP LLM05) does not: the payload is planted in content the model will later process during normal operation, and it activates when the model reads it. We've described the mechanism in What Is Prompt Injection. At the text layer, a successful indirect injection produces a bad response. At the action layer, it produces a bad action — the model encounters attacker-controlled text in a retrieved document and acts on it against a connected system, with no user in the loop to notice. This is the failure mode the next phase of the series examines directly, and it is the reason retrieval pipelines connected to tools warrant adversarial testing on the action path specifically.
What This Means If You're Wiring an LLM to Tools
The findings point to a small set of principles. None of them are exotic — they are ordinary security engineering applied to a new caller, which is the broader argument in AI Security Is Not a New Discipline. What changes is that the caller is non-deterministic, so the controls around it have to be deterministic.
- Authorize in the tool, not in the model. Every privileged operation should enforce object- and function-level authorization at the API boundary, scoped to the authenticated end user — independent of anything the model said to invoke it. Assume the model's request is attacker-influenced and check it anyway.
- Scope access per request, not per deployment. A model wired to a backend should operate with the calling user's privileges, not a broad service identity. Broad access granted once at integration time is the precondition for every BOLA finding above.
- Put confirmation gates outside the conversation. If an action needs human confirmation, that confirmation has to happen in a channel the model cannot author — an out-of-band approval, a deterministic policy check — not a sentence the model generates and then satisfies for itself.
- Treat safety classifiers as what they are. NeMo Guardrails, LlamaGuard, and input/output filtering meaningfully reduce upstream risk and belong in the stack. They are not a substitute for authorization on the execution path. Defense in depth means both, not either.
- Test the action path, not just the text path. A clean behavioral scan says the model is hard to talk into saying the wrong thing. It says nothing about what happens when the model is connected to systems that will act on its output. Those are different tests. The series ran both because they answer different questions.
The reframe is the whole point. Securing what a model says is necessary, and it is well-trodden ground. But the impact of an AI deployment lives where its output becomes an action — and that layer has its own failure modes, its own threat model, and its own controls. Treat the model as an untrusted caller and move the authorization decision somewhere deterministic, outside it. A model hardened to never say the wrong thing can still be made to do it, and the gap between the two is where the consequential findings keep appearing.