If your plan for securing AI agents is identity plus API permissions, Uber's engineers say that plan has a hole: a properly credentialed agent that has been manipulated will pass every check you have. Uber's answer, described in an engineering post published November 6, 2026, is to register every agent with a declared persona, permitted intents and constraints, then check each proposed action at runtime against that declaration using small, locally hosted guard models. The part worth copying first is the registry. The part that will cost you the most is tuning the checks for each agent, which Uber found it could not avoid.
The post comes from Sean Tout, Max Zhurovich and Adi Raghavendra of Uber Engineering, and InfoQ summarized it on November 15. It is one of the few public accounts of a large company describing the agent security stack it runs in production, including what went wrong.
Why Identity and API Permissions Are Not Enough for Agents
Authorization answers whether an agent may call a tool, and that is all it answers. Uber's post puts it directly: identity and authorization systems "can determine whether a user or service has permission to access a resource," as InfoQ quotes it, but they cannot judge whether an agent's proposed action fits the context it is operating in.
That gap matters because agents read untrusted content and then act on it. The Uber post lists the risks that live in that gap: prompt injection, tool and memory poisoning, goal hijacking, behavioral drift and hallucination-driven actions. Several map onto the OWASP Top 10 for Agentic Applications, released December 9, 2025, which highlights agent behavior hijacking, tool misuse and exploitation, and identity and privilege abuse.
Your existing least-privilege work still counts, because it limits how much a hijacked agent can reach. A hijacked agent can still use whatever it legitimately holds, and that is the case Uber built for. We covered the privilege half of this in our guide to agent authorization and standing privilege; Uber's design adds a layer on top of it.
What Uber Built: A Registry, a Scanner and a Runtime Check
Uber Secure AI has three layers: validation when an agent is provisioned, enforcement at runtime, and continuous assurance after deployment. The named pieces, all from Uber's post, fit the classic policy architecture most security teams already know:
| Component | Role in Uber's design | Policy role |
|---|---|---|
| Uber AI Registry | Records each agent's identity, owner, persona, permitted intents, constraints, dependencies and risk tier | Policy administration point |
| Argus | Scans code, prompts, configs, dependencies and tool paths; derives intents and pre-generates personas | Onboarding |
| AI Guard | Small, specialized, locally hosted models, some fine-tuned, run in parallel | Policy decision point |
| Agent Guard | Runtime hooks at agent and tool-execution boundaries | Policy enforcement point |
| LangFx and AI Guard SDK | Standard integration paths that call AI Guard | Enforcement plumbing |
An agent registry is a system of record that lists every agent an organization runs, who owns it, and what it is allowed to do. Uber's version stores more than permissions. It stores a behavioral contract: the agent's persona, the intents it may pursue and the constraints on how it pursues them.
At runtime, AI Guard evaluates each prompt and proposed action against that contract, plus the user's context and the multi-turn session history. The post gives the example that matters: an agent can hold valid credentials for a tool and still have the action denied, because the action falls outside its declared intents. Uber says this lets it block out-of-bounds actions even when the attack technique is new, since the check compares the action with the agent's declared purpose and needs no signature of the attack.
Argus does the unglamorous work that makes the registry real. It reads an agent's code and pre-generates a persona and intents, which the owning team reviews and refines. Separately, Uber scans its monorepo for agents nobody registered. If you are trying to count your agents today, that scanner is the piece you probably lack; shadow agents were already a measured problem earlier this year.
Third-party MCP servers and tools get static and dynamic analysis, software composition analysis, reputation signals and semantic inspection before use, per the same post. That is the same supply-chain problem we covered in MCP dependency drift.
What Broke and How Uber Fixed It
Uber's most useful admission is that uniform guardrails did not work. Generic controls and static thresholds were replaced with agent-specific personas, intents, constraints and risk-based calibration, according to the Uber post. Each agent has a different purpose and risk profile, so one threshold could not fit all of them.
Four problems, and the fix for each:
- False blocks against false allows. Stricter enforcement cut unsafe actions and raised false blocks. Uber ran guardrails in shadow mode first, replayed recorded traffic against candidate policies, and calibrated per agent so teams could measure both error types on real behavior before enforcing.
- Latency. Calling a large general-purpose model for every decision was too slow. Uber parallelized the guardrails and moved decisions to smaller specialized models hosted locally, citing network round trips and remote inference latency as the reason SaaS LLMs were impractical for every security call.
- Developer friction. Teams bypass controls that are painful to adopt. Uber automated onboarding and guardrail assignment, with Argus generating the first draft of each agent's intents.
- Generic controls. Replaced by per-agent contracts, which InfoQ's summary says "made enforcement more contextual and precise."
Uber publishes no false-block rates, latency figures or model sizes, so you cannot benchmark against it. For a sense of what "small and local" can mean, Meta's Llama Prompt Guard 2 classifiers come in 86M and 22M parameter versions and its model card reports 92.4 ms and 19.3 ms per classification on an A100 at 512 tokens. Those are public figures for a different model; Uber has not said what it runs.
Uber records unified execution traces that link agent actions, tool calls and guardrail decisions, and replays those interactions against new policies before turning them on. Without a replay corpus, every policy change is a bet on production. If your traces do not yet capture the decision, start with our agent audit logging guide.
The Tradeoffs Uber Says Are Worth Paying
Tight intents cost agents flexibility, and Uber says the trade is "real, and worth making today." The authors also write that the most effective mitigation they found "was also the least glamorous": restricting agents to explicit intents and constraints, as stated in the post.
They do not oversell it. The post says these controls "reduced risk and raised the cost of exploitation, but did not eliminate it," and that effectiveness against new injection techniques is "less predictable." That is consistent with outside work. Simon Willison has called himself "deeply suspicious" of guardrail vendors claiming to catch 95% of attacks, since in web security 95% is "very much a failing grade." A classifier-based check is probabilistic, and Uber's own wording accepts that.
The strongest counterargument came from a LinkedIn response that InfoQ cited. A UN senior IT officer quoted by InfoQ noted that per-agent effort "scales with the number of workflows," that restricting agents to explicit constraints is least privilege rather than a new idea, and asked how this applies to vendor or SaaS agents where "you can't insert your own enforcement hooks." Uber's post does not answer that last question; it says only that the next phase will extend the framework beyond its initial focus.
Deterministic Alternatives to Model-Based Checks
You do not have to start with guard models; deterministic controls cover part of the same ground at lower cost. Three published patterns are worth comparing with Uber's:
- Meta's Agents Rule of Two. Published October 31, 2025, it says an agent session should combine no more than two of three properties: processing untrustworthy inputs, accessing sensitive systems or private data, and changing state or communicating externally. If a task needs all three, the agent should not run autonomously and needs supervision such as human approval.
- CaMeL. The CaMeL paper separates control flow, taken from the trusted user query, from untrusted data, so retrieved content "can never impact the program flow." It solved 77% of AgentDojo tasks with provable security against 84% for an undefended system. That seven-point gap is the price of the guarantee.
- AWS AgentCore Policy. AgentCore Policy intercepts tool calls at the AgentCore Gateway and evaluates them against Cedar or Dogwood policies, including session-aware temporal rules and scores from Guardrails providers, logging each decision to CloudWatch.
Uber's semantic check catches actions a static rule cannot express, such as a request that is technically allowed but unrelated to what the user asked. Deterministic rules are cheaper and explainable. Most teams will want both: hard rules for the actions that must never happen, and a model-based check for the ambiguous middle. For commercial detectors such as Lakera, see our runtime guardrail comparison.
What to Do With Uber's Pattern
Start with the registry and discovery, because nothing else works without them. Runtime checks need a contract to check against, and you cannot write contracts for agents you have not found.
This Week:
- Ask each team running agents to list them, with an owner and a one-paragraph statement of what each agent is for. That paragraph is the first draft of a persona and intent set.
- Classify each agent against Meta's Rule of Two. Any agent that reads untrusted input, touches sensitive data and can act externally goes on a review list today.
This Month:
- Search your code repositories for agent framework imports and LLM SDK calls, and reconcile the results against the list. The difference is your unregistered agents, which is what monorepo scanning finds for Uber.
- Pick one high-risk agent and run a runtime check in shadow mode only. Log what it would have blocked for two weeks and have the owning team label each block as correct or false.
- Confirm your traces link the user request, the tool call and the guard decision in one record. If they do not, you cannot replay, and you cannot tune safely.
Before Your 2027 Security Budget Locks:
- Put per-agent tuning time in the budget next to the licenses. Uber's experience says a single threshold across agents fails.
- For every SaaS agent you buy, ask the vendor in writing where you can insert an enforcement hook, what pre-action events they expose, and whether you can block an action before it executes. Where the answer is none, limit that agent's scopes and treat its logs as your only control.
- When evaluating commercial guardrail vendors, ask for false-block and false-allow rates measured on your own replayed traffic.
The Bigger Picture
Anyone who ran a web application firewall will recognise the arc: generic rules raise false positives until someone tunes them to each application. Uber hit the same wall with uniform thresholds and solved it by writing the rules per agent, from each agent's declared purpose. A follow-up series from Uber Engineering is planned on personas, context-aware guardrails, intent filtering, prompt provenance and onboarding. If you run more than a handful of agents, register them before you buy a guard model.
Continue Reading
- Agent Authorization: Standing Privilege Is the Whole Problem
- NeMo Guardrails vs Guardrails AI vs Lakera: Buy the Detector
- Okta vs Entra Agent ID vs SailPoint: Two Issue, One Governs
- SalesBleed Turned a Public Web Form Into an Agentforce Data Leak
- monday.com Agents Resolve Half of 1,688 Infra Tickets a Month
- Human-in-the-Loop for AI Agents: Most Approval Gates Rubber-Stamp
