All articles
ArticlesNovember 16, 20267 min read

Securing AI agents: lessons from Uber's Secure AI framework

Securing AI agents takes more than API keys. How Uber's Secure AI framework checks if an agent's action fits its purpose, and what small teams can copy.

securing ai agentsuberai agent securityprompt injectionmcp securitybehavioral authorizationagentic aiapplication security
Securing AI agents: lessons from Uber's Secure AI framework

InfoQ wrote up Uber's agent security framework on November 15, 2026, and it sent me back to the original post from Uber Engineering. I read a lot of "how to secure your agents" content. Most of it is a list of guardrail products. This one is different because it comes from a company running agents in production, and it admits where its own controls fall short.

The core argument is one I agree with: securing AI agents is not mainly an identity problem anymore. Your agent can have valid credentials, the user can have legitimate access to the data, every API call can be authorized, and the agent can still do something nobody asked for because a web page or a document told it to.

Why securing AI agents breaks traditional authorization

Uber's post puts it plainly: identity and authorization systems can say whether a user or service may access a resource, but they "can't determine whether an agent's proposed action is appropriate in context."

That gap is where the agent-specific attacks live. Uber lists prompt injection, tool and memory poisoning, goal hijacking, behavioral drift and hallucination-driven actions. None of these need a stolen token. They work by steering an agent that already holds legitimate access.

Uber says it evaluated commercial AI security and guardrail platforms first. They helped with direct prompt injection, jailbreaks and sensitive data exposure, but none covered the case Uber cared about most: "an agent manipulated into an unintended action even when the user, agent, tool, and every API call are legitimately authorized."

So instead of chasing detection rules for every injection variant, Uber moved to checking behavior. The question changes from "is this agent allowed to do X?" to "should it do X, given what the user asked and everything that happened in this session?"

How Uber's Secure AI framework works

1. Provisioning: a behavioral contract for each agent

Before an agent ships, it goes into the Uber AI Registry with its identity, owner, persona, permitted intents, constraints, dependencies and risk tier. Uber calls this a behavioral contract.

Writing that contract by hand would be painful, so a platform called Argus analyzes the agent's code, prompts, configs, dependencies, endpoints and tool-call paths. It flags weaknesses and drafts the intents, and the team reviews them instead of starting from a blank page.

The same scrutiny applies to the supply chain. Third-party MCP servers and tools get static and dynamic analysis, dependency scanning, reputation checks and semantic inspection of tool descriptions, which is where tool poisoning hides. Monorepo scanning also looks for unregistered agents and unauthorized MCP endpoints.

2. Runtime: behavioral authorization

At runtime, Uber reuses the classic policy model and stretches it:

  • The AI Registry is the policy administration point (PAP).
  • AI Guard is the policy decision point (PDP).
  • Agent Guard hooks, plus LangFx and the AI Guard SDK, are the policy enforcement points (PEP).

The hooks call AI Guard at checkpoints such as tool execution and apply its verdict before the action goes ahead. An agent can hold valid credentials for a tool and still get denied because the action is outside its intent or doesn't fit the session.

The engineering detail I liked most is about latency. These checks sit in the request path, so Uber doesn't send every decision to a big hosted LLM. AI Guard uses small, specialized models hosted locally, some fine-tuned for one guardrail job, running in parallel with in-memory vector search for semantic matching.

3. Continuous assurance: traces and replay

After deployment, a unified execution trace links agent actions, tool calls and guardrail decisions. Prompt and response content is only captured when needed, sensitive data is minimized or redacted, and traces have retention limits.

Recorded interactions can be replayed against new guardrails and policies before they are enforced. Automated threat modeling and continuous red teaming feed findings back into risk scores and policies.

What went wrong on the way to production

This is the most useful part of Uber's write-up because it is honest about the trade-offs.

The first problem was false blocks versus false allows. Strict persona and intent policies broke legitimate work, loose ones weakened protection. Uber handled it with shadow mode, traffic replay and per-agent calibration.

Then latency. Stacking static, contextual and semantic checks slowed user-facing flows. Running guardrails in parallel and moving decisions to smaller models fixed most of it.

Developer friction came next. Manual registration and policy writing slowed teams down, and Uber notes that a control people bypass gives you little. Argus pre-generating personas and intents is the answer here.

Finally, generic controls weren't enough. Uniform thresholds couldn't cover agents with different purposes and risk profiles. Agent-specific intents and constraints worked better.

Uber's conclusion is refreshingly modest. The guardrails "reduced risk and raised the cost of exploitation, but did not eliminate it," and their effect on new injection techniques "remained less predictable." The best mitigation, in their words, "was also the least glamorous: restricting agents to explicit intents and constraints." They call that trade-off "real, and worth making today."

What I'd copy for a smaller team

Most of us don't have an Argus or a team to fine-tune guardrail models. You don't need them to get most of the value. As a security engineer working on agent features in erxes, this is the order I'd go in:

  1. Write the contract down. For each agent, list the tools it may call and the conditions for each one. "Can refund orders under $50 for the requesting customer" beats "has the orders API." This is least privilege, as one LinkedIn commenter quoted by InfoQ pointed out, and that's fine. It's the part that works.
  2. Put one choke point in front of tool calls. A single function every tool call goes through, where you check the action against the contract and the user's original request. That's your PEP. It can start as plain code.
  3. Treat MCP servers like dependencies. Read tool descriptions before you install them, pin versions, and don't let an agent discover new tools at runtime. My notes on the Cursor security incident show how fast a trusted extension can turn into a backdoor.
  4. Log every tool call with its reason. You can't calibrate or replay what you never recorded.
  5. Run new rules in shadow mode first. Uber's false-block problem will hit you too.

Payments are where this matters first. When I looked at ChatGPT Wallet and agent payments, the protective design was the same idea: the agent proposes, and a separate control decides.

The open question

The fair criticism, also raised in the InfoQ piece, is that this model assumes you own the agent. Hooks and registries work for agents you build. For vendor and SaaS agents, you can't insert your own enforcement points, and that's where a lot of enterprise agent use will happen.

Uber says this is the first post in a series, with deeper write-ups planned on agent personas, context-aware guardrails, observability, intent filtering, constraints, prompt provenance and secure onboarding. The prompt provenance piece is the one I'm waiting for, since tying each privileged action back to something a person actually asked for is the most direct answer to indirect prompt injection I've seen.

FAQ

What is Uber's Secure AI framework?

It is Uber's internal defense-in-depth framework for AI agents. It covers three stages: provisioning-time validation through the Uber AI Registry and Argus, runtime enforcement through AI Guard and Agent Guard hooks, and continuous assurance through traces, replay, threat modeling and red teaming.

What is behavioral authorization for AI agents?

It is a check on top of normal access control that asks whether a proposed action fits the agent's defined purpose, the user's request and role, and the session so far. An action can be denied even when every credential involved is valid.

What was the most effective control Uber found?

Restricting agents to explicit intents and constraints. Uber says it substantially reduced the ability to act on manipulated instructions, at the cost of some flexibility.


Sources

Cover image: Uber logo, Wikimedia Commons (public domain)

Related articles