A single security signal may be enough to stop an autonomous action, but it’s rarely enough to justify one. When we think of today’s AI world, agents are everywhere. An agent as such can be authenticated, its application approved, its data access permitted and its tool call valid, yet the action it takes can still exceed what the original task authorized.
As security and risk practitioners, we’ve spent decades securing individual requests. However, when AI agents can execute actions across enterprise systems, authorization may depend on information established several steps earlier, by a different actor or in another application. If that information is unavailable when the final decision is made, a technically valid request can produce an unauthorized outcome.
What Changes When Agents Execute
Context has always been part of security decisions. We use identity, permissions, device posture, transaction risk and other signals to determine whether an action should be permitted. Attribute-Based Access Control (ABAC), Zero Trust and adaptive authentication are established examples. Distributed systems have also managed delegation and authorization across services for years.
Autonomous agents make these problems more difficult because they interpret objectives, retrieve information, delegate tasks and invoke tools. The person who initiated the work may not see every intermediate decision.
Consider this chain:
Human → Agent K → Customer Data → Agent J → Payments Service → Action
Every interaction may pass its own security checks while the payment at the end exceeds what the manager authorized. The payments service needs more than confidence in the caller. It must establish that the caller has authority for this payment within this execution.
Meet Agent K and Agent J
A customer operations manager asks Agent K to examine complaints from the previous 30 days and identify customers who may qualify for remediation.
The manager is authenticated. Agent K legitimately retrieves customer records and delegates part of the analysis to Agent J. After reviewing several cases, Agent J concludes that some customers may qualify for refunds and attempts to issue one.
Agent J is a legitimate workload. In other approved processes, it is permitted to invoke the refund API. The customer data was retrieved properly, the payment request is technically valid and the customer may even deserve the refund. Nobody needs to steal a credential or compromise a model for this to happen.
However, the manager asked for an assessment, not a payment.
Agent J’s technical capability to call the refund service does not establish authority to issue this refund.
This resembles the confused deputy problem, where a component with legitimate privileges uses them outside the authority of the task it is carrying out. Properly scoped authorization could stop it. The failure occurs when the payments service checks Agent J’s general permissions without validating the limits of the current execution.
Identity, Intent and Authority
Identity tells us who or what is acting. Authorization determines which actions are permitted, against which resources and under what conditions.
Natural language intent introduces another consideration. An instruction describes what someone wants accomplished, but that description is not automatically an enforceable authorization policy. Asking an agent to identify potential refund candidates does not authorize it to transfer money.
NIST’s February 2026 concept paper examines applying established identity and authorization practices to software and AI agents. Research presented at ICML 2025 on authenticated delegation considers how existing protocols could support constrained and auditable authority between agents.
I use four questions to examine a delegated execution:
Requested → Delegated → Permitted → Observed
What was requested? What did Agent K delegate? What did Agent J have authority to do? What actually happened?
A difference between these states requires examination, although it does not automatically establish a security incident.
The security model must also determine who can grant permission. An agent cannot create payment authority by interpreting an instruction more broadly than intended. Delegation should preserve or narrow existing authority. Any increase must come from a principal or service authorized to grant it.
Where the instruction is ambiguous, the system should obtain explicit authorization before a consequential action proceeds.
What I Mean by Context Convergence
IAM may know Agent J’s identity. The payments platform knows its API permissions and transaction details. The agent platform may retain the delegated task. A policy service knows the approval requirements, while runtime records show which tools were invoked and what occurred earlier.
I use context convergence to describe making the trustworthy, relevant information available when a policy decision is required. This does not mean collecting every log or building a single platform to control every agent.
It is also different from orchestration. An orchestrator coordinates tasks, agents and tools, and may invoke a policy service. Context convergence addresses whether that service has sufficient reliable evidence to determine whether the action is authorized.
An orchestrator can execute the correct sequence and still produce an unauthorized outcome if the information supporting its authorization decision is incomplete.
The policy decision must come from an authorized mechanism, with enforcement at the protected resource or another control the agent cannot bypass. For payments, verifying authority after money has moved is too late.
For consequential actions, the security relationship should be:
Authoritative Permission → Bounded Delegation → Verified Context → Policy Decision → Enforcement → Recorded Outcome
These represent security responsibilities, not necessarily separate products. They establish where authority originates, how delegation is constrained, what evidence supports the decision and where execution can be stopped.
Context Has to Be Trustworthy
More information does not guarantee a sound decision.
An agent can misrepresent its delegation. An approval can be genuine but expired. A signed claim can establish who issued it without proving that the issuer was authorized to grant the permission. A valid authorization can also be presented for the wrong transaction.
For a payment, the evidence may need to identify the authorizing principal, acting workload, customer, amount, currency, permitted operation, approval and expiration.
The payments service must also verify that the authorization applies to the transaction being requested.
Cryptographic signatures, protected communication and authoritative policy services can help establish trust. However, a signature cannot prove that the underlying permission was justified. That requires authorization rules and evidence of the issuer’s authority.
I call the loss of a necessary security constraint across a workflow context degradation.
At the beginning of the execution, the enterprise knows that the manager requested an assessment. Several calls later, the payments service may see only an authenticated agent and a refund request.
The information in that request can be accurate while the authorization constraint has disappeared.
This does not justify passing every prompt, customer attribute or execution record between systems. Privacy and data minimization still apply. The receiving service needs only the evidence required for its decision, along with a reliable means of verifying its source, scope and current validity.
OAuth and Existing Controls Still Apply
There is no need to replace IAM, OAuth or Zero Trust to address this problem.
OAuth 2.0 Token Exchange, defined in RFC 8693 supports token exchanges involving delegation. RFC 9396 provides Rich Authorization Requests for more detailed permissions. Sender constrained tokens can reduce certain risks associated with stolen credentials and token replay.
These mechanisms are relevant, but they do not independently establish whether the manager’s original instruction authorized a refund. Nor does token exchange, by itself, determine the policies governing delegation.
The authorization service must enforce those policies, and the payments service must verify the resulting permission against the actual transaction.
If Agent J has authority only to analyze customer records, the refund must be denied.
A separate approval may authorize the payment but it should identify the specific transaction and be verified before execution. For sensitive operations, the approver should see the exact details through a trusted approval mechanism rather than relying entirely on an interface controlled by the agent.
Authorization can also change during execution. Permissions may be revoked, approvals may expire and transaction limits may be exhausted.
Consequential actions therefore need authorization checks sufficiently close to execution, with appropriate protection against replay and duplicate transactions.
If the required authority cannot be verified, the action should be denied or held for approval.
Earlier Events Can Change Later Actions
AgentDojo, published at NeurIPS 2024, examines how untrusted information returned to agents can influence subsequent behavior through prompt injection. Agent Security Bench, published at ICLR 2025, evaluates attacks involving prompts, tools and memory.
These studies demonstrate how earlier interactions can affect later agent behavior. They do not establish that context convergence alone prevents such attacks.
A retrieved document can instruct an agent to issue a refund. A tool response can alter its plan. Neither is a legitimate source of payment authority.
The distinction between information used for reasoning and authority used for execution must remain enforceable, regardless of how convincingly an agent explains its proposed action.
OpenTelemetry can help establish relationships between events across services but distributed tracing is not an authorization mechanism. A trace identifier connects operations. It does not prove who delegated authority or whether a payment was approved. Incoming tracing information may also be forged.
Execution records are important for investigation and accountability. They do not replace authorization checks before an action proceeds.
Assurance Should Follow Consequence
Reading public documentation should not require the same controls as accessing sensitive customer information or issuing refunds.
As the consequence of an action increases, the enterprise may need narrower permissions, stronger evidence of delegation, more current authorization and additional approval.
NIST's AI Risk Management Framework addresses risk within its operating context. The OECD AI Principles address traceability and accountability. The EU AI Act establishes logging, human oversight and cybersecurity requirements for systems subject to its relevant high-risk provisions.
None prescribes a context convergence architecture, and their obligations should not be treated as interchangeable.
The security requirement is to determine what evidence is necessary for a particular decision, verify that evidence and ensure the responsible enforcement point can act on it.
Back to Agent J
Agent J is authenticated. Its access to customer information is legitimate and the customer may deserve the refund.
Those facts alone do not establish authority to execute the payment.
The payments service needs to establish who authorized the refund, whether Agent K could delegate payment authority, whether the required approval remains valid and whether the transaction falls within the permitted limits.
Context convergence makes the relevant evidence available. Policy determines whether the action is authorized. Enforcement prevents execution when authority is absent.
Orchestration can coordinate these functions but it cannot substitute for them.
That is why I believe AI security is becoming a context convergence problem. Existing security controls remain essential but they cannot enforce constraints they never receive or cannot trust.
As autonomous execution crosses agents, models, tools and enterprise applications, security must account for more than the legitimacy of the immediate request. It must also consider the authority and execution state that produced it.
The unit of security is expanding from the individual request to the execution chain around it.
Author's note: Thanks to Gagan Satyaketu for your support of this blog post.