Uber creates framework to decide whether an AI agent's action is appropriate in context

- Reading
- 6 min
The company detailed a framework that goes beyond identity and API permissions to assess whether an autonomous agent's action makes sense in context, covering the agent's entire lifecycle.
In an article recently published by Uber's engineering team and reported by InfoQ on November 15, 2026, the company described the limitations of traditional identity and API controls when facing AI agents that dynamically reason about external content and take real actions in the world. To address the problem, Uber built a framework that tries to answer a different question than the one identity systems have always answered.
Why identity and API permissions are no longer enough
Identity and authorization systems tell you whether a user or service can access a resource. They don't tell you whether the action an agent is about to take makes sense given the user's request, the agent's purpose, its permissions, and the context of the interaction.
Identity and authorization systems can determine whether a user or service has permission to access a resource, but they can't determine whether an agent's proposed action is appropriate in context.
Uber Engineering, in the original article
This gap opens room for risks that didn't exist (or were much smaller) in systems that only executed deterministic code:
- prompt injection;
- tool and memory poisoning;
- goal hijacking;
- behavioral drift over time;
- actions triggered by model hallucination.
The framework's three layers, from provisioning to runtime
Uber's framework covers the agent's entire lifecycle in three layers: pre-deployment, runtime enforcement, and continuous assurance after deployment.

Provisioning: registration and automated analysis
Before going into production, every agent needs to be registered in Uber's AI Registry, which establishes identity, ownership (who owns the agent), persona, allowed intents, constraints, dependencies, and risk classification. This process is automated by a tool called Argus, which analyzes source code, prompts, configurations, dependencies, exposed endpoints, and the agent's tool invocation paths to identify security weaknesses. The same analysis is applied to MCP servers and to the tools agents use, not just to the agent itself.
Runtime: from permission to behavioral authorization
The traditional security model (policy administration, policy decision, and policy enforcement) is extended with what Uber calls behavioral authorization: the evaluation of whether an action is appropriate in that context, not just whether it's technically allowed. This layer has three pieces that work together:
- the AI Registry, which defines and manages policies, personas, intents, and constraints per agent;
- the AI Guards, which evaluate interactions and proposed actions against those policies;
- the Agent Guard runtime hooks, which trigger the AI Guard at critical checkpoints and enforce its verdict before letting an interaction or action proceed.
Post-deployment: continuous assurance
Once the agent is live, the focus shifts to what Uber calls Continuous Assurance, supported by end-to-end observability, auditing, explainability, and replay. Two pieces sustain this layer: a unified execution trace that connects agent actions, tool calls, and security decisions into a single thread; and the ability to replay recorded interactions whenever policies and guardrails are updated, to measure the effect of the change before trusting it in production.
The trade-offs Uber itself acknowledges
In the original article, Uber is explicit about the friction of putting all this into production. The company cites four recurring tensions:
- calibrating how restrictive policies are so they don't generate excessive false positives or leave protection gaps;
- keeping runtime latency low, since every guard checkpoint adds cost to execution;
- reducing friction for the development team when configuring the framework for a new agent;
- moving from generic controls to agent-specific policies, which made enforcement more contextual and precise.
The debate among security architects
The post gained traction among security and architecture professionals on LinkedIn, according to InfoQ. Tristan G., senior information technology officer at the UN, praised the use of personas, intents, constraints, and per-agent calibration as what adds the most value, but pointed out a cost that grows along with scale:

By its own account, the strongest control was restricting agents to explicit constraints, which is least privilege rather than a new idea. For me, the open question is how this works for agents you don't build, such as vendor or SaaS agents where you can't insert your own enforcement hooks.
Tristan G., senior information technology officer at the UN, in a LinkedIn comment
AI architect Pratik Dhanave reached a similar conclusion, highlighting that the point Uber calls "least glamorous" is exactly the most effective:
The lesson they call least glamorous is the one they rate most effective: explicit intents and constraints per agent. Not generic thresholds, which failed because every agent has a different purpose and risk profile. The cost is flexibility, and they say it is worth paying.
Pratik Dhanave, AI architect, in a LinkedIn comment
What changes for those building agents in Brazil
Few companies in Brazil have Argus, the AI Registry, or the dedicated team that Uber assembled to support this framework. But the logic behind it is replicable with what already exists in the ecosystem: a central catalog of agents with defined owners and scope, explicit policies per agent (instead of a generic "trust" threshold applied to everyone), and a runtime enforcement point before any sensitive action, something that can already be prototyped with policy engines like OPA and with instrumentation via OpenTelemetry to build the execution trace.
The most relevant point for those deciding architecture here is the question Tristan G. left open: what to do with vendor and SaaS agents, where there's no access to insert your own enforcement hooks. Much of the Brazilian teams putting agents into production today aren't building from scratch, they're plugging Copilot, Agentforce, or equivalent assistants directly into internal processes, exactly the scenario in which Uber's model doesn't apply without adaptation.
It's also worth noting that the treatment given to MCP servers in the framework (the same risk analysis applied to agents is extended to the tools they call) is a sign of where agent governance is headed: it's not enough to audit the agent, you need to audit every piece it can trigger. For teams exposing tools via MCP to internal or third-party agents, this is a review layer that still tends to fall outside the security scope.
InfoQ itself closes the coverage by saying that Uber's framework is still evolving, with plans to expand capabilities across all the described areas. There is, so far, no indication that any component will be open-sourced as a tool or public specification, which means the practical value of the material, for now, lies in the design principles, not in a package to install.
Translated from the Brazilian Portuguese original · Read the original
AWS Nitro Sandboxes isolates each EKS pod in a microVM with a single configuration line
AWS launched Nitro Sandboxes, a feature that runs each EKS pod, ECS task, or EC2 workload inside its own microVM with a separate kernel. The change in a Kubernetes cluster comes down to a single field in the pod manifest.






