Est.

Insecure Direct Object References in AI Agent Tool Calls

Agents can be tricked into forging object IDs, so check ownership.

· 8 min read
Cover illustration for “Insecure Direct Object References in AI Agent Tool Calls”
AI Application & MCP Security · November 12, 2026 · 8 min read · 1,899 words

Insecure direct object references in AI agent tool calls are an authorization failure with a new attack path. An attacker can manipulate the model into supplying the reference that crosses an account boundary. A policy-based authorization check is required before each tool call executes, covering the caller, the action, and the specific object.

What IDOR actually is and why its definition matters for agents

Authentication establishes who a caller is. Authorization decides what that caller may access. Insecure Direct Object Reference, or IDOR, occurs when an application takes an object identifier without checking whether the caller is allowed to use the object it names. The caller can be properly signed in. The missing step is the object-level check, such as confirming that a requested record belongs to the caller’s account or workspace.

OWASP API Security places the API form of this flaw, Broken Object Level Authorization, first in API1:2023. Broken Access Control, its parent category, also holds the top position in the OWASP Top 10. Horizontal IDOR crosses between accounts at the same privilege tier, while vertical IDOR reaches objects that need higher privileges, including restricted configurations or management functions. Neither requires authentication to fail. This definition needs extending for agents because the caller supplying the reference can be an LLM acting on someone else’s instructions.

How AI agents execute actions and what an object reference means in that context

An agent can do more than return text. To act, the model generates a structured request naming a function and supplying its parameters. These tool calls can query databases, transfer funds, execute code, send messages, or delegate work to another agent. The application then decides whether to execute the request. That handoff is the boundary between language generated by a model and an operation performed by a downstream system.

Object references sit inside those parameters. The Amazon Strands tools mongodb_memory, elasticsearch_memory, and mem0_memory take a namespace parameter that names the memory context to use. Flowise’s OpenAI Assistants endpoints accept a credential UUID, while other operations can reference a workflow version integer or a conversation ID. These are not merely descriptive labels. They select the data, credentials, or state on which an operation will act.

The client supplying those values is now the model. Its output still needs an authorization decision. In a multi-tenant platform, different customers share the same orchestration layer, so a reference that goes unchecked can select another customer’s resources. The tool-call boundary is therefore where the application must distinguish what the model has requested from what the calling context is allowed to do.

Why the LLM itself becomes a vector for forging and enumerating object references

Classic web IDOR usually puts the attacker’s hand directly on the identifier. In an agent system, the attacker can instead persuade the model to generate the identifier and submit it through a tool call. The model becomes a proxy for the attack. That changes the attack surface because the dangerous value can originate in model output, even when the user never supplied it as a structured parameter.

Research published at ICLR 2026 distinguishes Direct Tool Invocation from Indirect Tool Invocation. Direct invocation uses a crafted prompt to ask for a tool call that is not allowed. Indirect invocation hides instructions in a web page, document, or other content from outside that the agent reads. Here, the attacker need not be the user. The user can request a legitimate task while attacker-controlled material redirects the agent toward an unauthorized operation.

The Strands http_request tool shows how that indirect route works, though the way it discloses credentials differs from a failure to check object ownership. The model could control a proxies parameter, and instructions delivered through untrusted web content could point it at an actor-controlled endpoint. The hostname allowlist check still passed and the credential was attached, but the request went through the actor’s proxy. This disclosed the credential in cleartext in the Authorization header.

For IDOR, the corresponding manipulation targets an object reference. Neither direct nor indirect invocation needs to break authentication. Both can work within an authenticated session and take advantage of a missing ownership check. Guessable identifiers also make enumeration tractable. In the 2025 McDonald’s McHire chatbot case involving Paradox.ai, Ian Carroll and Sam Curry incremented and decremented their own lead_id to retrieve other applicants’ chat transcripts, contact details, and session tokens. That case demonstrates the risk of sequential references.

What the CVE record shows: documented IDOR in production agent platforms

Flowise’s CVE-2026-67622, scored CVSS 9.9, shows why a credential UUID is not an access control. An authenticated attacker could supply an arbitrary UUID to the Assistants endpoints, and the credential lookup lacked a workspace-scoped ownership check. The lookup trusted the reference without establishing its owner. The impact included enumerating assistant metadata, retrieving file and vector store listings, and uploading files into victim workspaces. Versions through 3.1.4 were affected.

The AWS security bulletin identifies CVE-2026-19111 in the three Strands memory tools, with a CVSS score of 8.1. An authenticated remote user could influence the model to emit a forged namespace and thereby access, modify, or delete another tenant’s memories. The reference selected another tenant’s stored context. The fix required upgrading to version 0.8.3.

A separate Strands issue affected shared conversation state. CVE-2026-115419 allowed an authenticated remote user to access another caller’s conversation history or influence model behavior for other callers in multi-tenant deployments. It affected versions of Python strands-agents that contained multiagent.a2a before 1.43.0 and versions of TypeScript @strands-agents/sdk before 1.5.0. The exposed object was the conversation itself. Isolation between callers failed even though they were authenticated.

CISA added Langflow CVE-2026-55255, an Authorization Bypass Through User-Controlled Key vulnerability, to its catalog of vulnerabilities known to have been exploited on July 7, 2026. The shared defect is not a particular identifier format but the absence of a reliable authorization decision for the resource it selects.

Why model alignment and input validation are not authorization

Model alignment guides behavior but does not establish ownership. A system prompt can tell an agent to use only the current customer’s records, but that instruction does not check a credential store or enforce a tenant boundary. Content the agent is meant to process can manipulate the parameters it generates, as the indirect invocation mechanism shows. Permission checks must work even when the model gives in to that manipulation.

Input validation solves a different problem as well. A schema can establish that a UUID has the right form, an integer is within an accepted range, or a namespace is a string. None establishes who owns the referenced object. Flowise’s failure required a workspace ownership check. A perfectly valid identifier can name a resource the caller has no right to use.

There is a real implementation difficulty here. Tasks can be unclear, and deterministic pre-action checks can block work that should be allowed if its intended scope is poorly defined. The field also has no agreed way to judge how well least-privilege mechanisms work. Those limits mean policies need care in how they are designed and must still be enforced. Otherwise, the model’s interpretation of a task becomes its own permission grant.

The five levels at which least privilege must be enforced in agent systems

Diagram: Five Levels Where Least Privilege Must Be Enforced. Visualizes: Show a vertical stack of five enforcement levels for AI agent authorization, ordered from broadest to narrowest scope: (1) Tool Inventory — only tools needed for the task…

For teams designing the authorization layer, least privilege begins with the tool inventory. Only tools needed for the task should be loaded, rather than a broad collection exposed at initialization. Invocation-level enforcement then checks whether the current workflow step legitimately requires the selected tool. A tool can be available in general without being authorized at this point in the task.

Argument-level enforcement narrows the decision to the requested action’s target and scope. It checks the specific object, recipient, query, path, amount, or payload supplied by the model against the calling context’s permissions. This is where object ownership gets enforced. Permission to invoke a memory tool does not imply permission to select another tenant’s namespace, just as permission to use an Assistants endpoint does not grant access to every credential UUID. The decision must happen at execution time.

Data-level enforcement limits what comes back to the model. Returning a full record when only part is needed can expose embedded API keys, bearer tokens, or session tokens unnecessarily. Delegation then controls authority passed to a sub-agent. An agent assigned to read a document should not inherit the parent’s write credentials. The subtask, rather than the parent’s total access, must define the delegated scope.

A tenant administrator who knew another tenant’s agentId could assign, unassign, or toggle skills on that agent, and runtime load_skill trusted those assignments. That let an attacker use capability assignment for cross-tenant prompt injection. Checking the skill alone was not enough. All five levels need enforcement by a policy engine outside the model.

What a policy-based authorization check at the tool-call boundary actually requires

The 2026 Singapore AI Safety Consensus calls for capabilities scoped to the minimum needed for the current task and context, with scope changing as the task evolves. Vendor advisories and CISA vulnerability bulletins point toward the same requirement. Static permissions alone do not cover that need. Enforcement must restrict capabilities dynamically and isolate execution, rather than treating an initial grant as permission for every later step.

Identity has to be established before those checks can work. When exposed MCP instances allow authentication bypass, they cannot reliably decide whose resources a call may access. Once the caller’s identity is known and trusted, every tool that takes an object identifier must check ownership before it runs. For Flowise’s pattern, that means checking that the credential UUID belongs to the calling workspace. UUID syntax supplies no substitute for that relationship.

The data layer must also enforce tenant scoping for conversation state, credential stores, and workflow versions. Validating the namespace supplied by the model closes the gap in the Strands memory case, while keeping callers isolated from one another fixes the separate conversation-state failure. Skill assignment needs a related reachability check. The assigning tenant must be authorized to reach the target agent.

Logs need the tool invocations, their scopes, and downstream authorization decisions. After cross-tenant access, the model’s response alone cannot show which resource the tool used or why the call was allowed to access it. The pre-action check is still needed when logging is in place. It makes the enforcement decision available for investigation rather than leaving the decisive action outside the record.

What this means for teams building or buying AI-powered SaaS products

For engineering leaders, the practical task is to review the authorization path. The inventory should be limited to the task, and sub-agent credentials should be limited to the subtask. Audit logs must expose tool arguments and authorization decisions.

A rigorous security review needs access to the implementation. A tester observing only the application from outside cannot establish whether the server validates a namespace parameter or trusts it unchanged. The review needs whitebox access to see how tool-call logic works, how authorization is enforced, and how multi-tenant data scoping is checked. CISA’s Langflow listing makes this review a priority now for products with agents that are already deployed. It is not a future hardening exercise.

Continuous scanning on pull requests is also needed because tool schemas and permission grants change as tools are added. A one-time audit cannot catch a later tool that accepts a bare integer without a scoping check. The system must be able to deny an unauthorized action even when the model requests it.

Sources

  1. Vulnerability Summary for the Week of August 3, 2026
  2. Before the Tool Call: Deterministic Pre-Action Authorization for Autonomous AI Agents
  3. What Is Insecure Direct Object Reference (IDOR)?
  4. The Vulnerability With No CVE: Managing Persistent Gaps Between Mandate and Authority in AI Coding Agents

More in AI Application & MCP Security