How Uber Uses Provisioning “Contracts” to Prevent Agentic Drift

Enterprise AI agents are getting very good at doing things nobody asked them to do.

Give one a support ticket and it will decide a refund is justified, find the right internal API, and issue it. Give it an incident and it will investigate, open a pull request, and tweak a monitoring threshold. It can chain tools, hand work to other agents, and move across systems faster than any human can review.

That’s the promise of agentic AI, and it’s also the problem.

An agent with valid credentials, legitimate tool access, and a believable user request can still do something the business never intended. Traditional authorization answers “Can this identity access this resource?” It can’t reliably answer the question that matters more: “Should this agent take this action, in this context, on behalf of this user?”

Uber’s answer is to stop treating autonomy as an open-ended capability and start treating it as a governed privilege. Under its Secure AI framework, every agent has to pass through a pre-deployment AI Registry, where its identity, ownership, persona, permitted intents, constraints, dependencies, and risk tier add up to a behavioral contract. Only after that can the agent run in production, under runtime enforcement.

The lesson is an uncomfortable one, but hard to avoid: mission-critical agents don’t need infinite flexibility. They need bounded autonomy.

“Uber has an AI registry”

Most coverage of Uber’s approach stops at the obvious: Uber keeps an internal registry and policy engine to manage agents across their lifecycle.

True, but it undersells what’s going on.

A registry here isn’t just a list of agents. It’s the authoritative record of what an agent is, who owns it, what it may do, which tools and resources it can use, and which controls follow it into production.

The more interesting question isn’t whether Uber tracks its agents. It’s this: what does Uber refuse to let an agent do, and at what point does it say no?

Agents need contracts, not vibes

Most enterprise AI conversations still treat an agent as a clever prompt wrapped around a few tools. You describe it by its model, its instructions, and maybe a list of integrations.

Uber starts from a different place: a behavioral contract.

That’s a machine-readable, reviewable declaration of an agent’s operating boundaries:

  • Who owns the agent
  • What identity it uses
  • What persona it’s allowed to project
  • Which intents it may pursue
  • What constraints limit its behavior
  • Which tools, MCP servers, APIs, and data sources it may depend on
  • What risk tier it belongs to
  • Which guardrails must be applied before it acts

Taken together, these define what the agent is designed and permitted to do. And it’s a different thing from ordinary access control.

Question Traditional authorization Behavioral authorization
Core question “Can this identity access this resource?” “Should this agent take this action in this context?”
Focus Identity, roles, permissions Intent, persona, context, constraints
Failure mode Over-permissioned credentials Plausible but out-of-scope action
Enforcement point API or resource access Agent reasoning and tool execution
Governance artifact Access policy Behavioral contract
Example denial “This service cannot call this API.” “This agent may check refund eligibility, but cannot issue a high-value refund without approval.”

Uber pushes access control past “who” and “what” to “why,” and to whether an action is appropriate at all. An agent can hold valid credentials, and the user can have legitimate access to the underlying resource, and the action can still be denied because it falls outside the agent’s declared intent or contradicts the session context.

That’s the core idea: authorization is necessary, but it’s no longer enough.

Inside Uber’s behavioral contract

The AI Registry sets up the contract before deployment. It records the agent’s identity, ownership, persona, permitted intents, constraints, dependencies, and risk tier. Each field exists to head off a different kind of drift.

Contract element What it bounds Drift it prevents
Identity and owner Which agent is acting and who is accountable Orphaned agents, unclear accountability, impersonation
Persona The agent’s role, authority, tone, and decision boundary Role confusion and overreach
Permitted intents The purposes the agent may pursue Goal hijacking and scope creep
Constraints Operational, safety, data, and tool limits Unsafe or noncompliant actions
Dependencies Models, tools, MCP servers, APIs, and data sources Silent expansion of the attack surface
Risk tier The oversight and controls required One-size-fits-all governance

And the contract isn’t something engineers write once and forget. Uber’s Argus platform analyzes an agent’s source code, prompts, configurations, dependencies, exposed endpoints, and tool-invocation paths. It finds weaknesses and derives structured intents from the actual implementation, so Uber can compare what developers say the agent does with what it can really do.

That comparison matters a lot. An agent might call itself a “customer support assistant,” but if its code can hit a payments API, edit account records, or read sensitive customer data, then its declared persona and its real capabilities don’t match. Argus surfaces that gap before production traffic turns it into an incident.

The trade-off: creativity versus determinism

Here’s the hard part: strict contracts cost flexibility.

An agent limited to explicit intents can’t improvise its way into neighboring workflows. It can’t decide a support task has turned into a payments task. It can’t quietly widen its tool use because the model guessed another API might help, and it can’t treat a vague instruction as permission for something consequential.

That loss is real, and Uber says so plainly. Restricting agents to explicit intents and constraints sharply reduces their ability to act on manipulated instructions, but it gives up some of the flexibility that makes autonomous designs appealing. Uber’s conclusion is that the trade is real, and worth making today.

The useful reframe is that creativity isn’t the same as autonomy.

An enterprise agent can still be creative in plenty of places:

  • It can make sense of a messy customer request.
  • It can pick the best way to explain a policy.
  • It can plan a sequence of safe investigation steps.
  • It can adapt its response as new information comes in.
  • It can summarize, classify, draft, and recommend.

But once an action has consequences (issuing a refund, changing infrastructure, touching sensitive data, sending a communication, modifying a production system), the agent shouldn’t be the one deciding whether it’s appropriate. That decision should be governed.

Dimension Open-ended agent Contract-bound agent
Flexibility High, but hard to predict Bounded, but predictable
Failure mode Silent scope creep Explicit denial, escalation, or fallback
Accountability Often unclear Named owner and auditable policy
Security posture Depends on detection Prevents out-of-contract action
Enterprise readiness Strong for experimentation Strong for production
Innovation Fast, but risky Controlled, repeatable iteration

The goal isn’t to make agents dumb. It’s to make them dependable.

How enforcement actually works

"Flow diagram showing an AI agent's refund request passing through an Agent Guard hook to AI Guard, which checks the AI Registry policy and then allows, escalates, or denies the action."

Uber’s framework isn’t one guardrail bolted onto a chat window. It’s a three-layer lifecycle: validation at provisioning time, enforcement at runtime, and continuous assurance afterward.

1. Provisioning: write the contract

Before an agent gets anywhere near production, Uber establishes its identity, ownership, persona, intents, constraints, dependencies, and risk tier in the AI Registry.

This is where the organization has to answer some basic questions:

  • What business problem does this agent solve?
  • Who’s responsible if it misbehaves?
  • What is it allowed to do?
  • What is it explicitly not allowed to do?
  • Which tools can it touch?
  • What happens when it hits an edge case?
  • How much damage could it do if compromised?

An agent doesn’t earn autonomy by being technically impressive. It earns it by accepting a defined operating envelope.

2. Runtime: enforce the contract

At runtime, Uber separates policy administration, policy decision, and policy enforcement.

The AI Registry is the policy administration point, where agent policies, personas, intents, constraints, and required guardrails are managed. AI Guard is the policy decision point, checking interactions and proposed actions against those policies. Agent Guard’s runtime hooks and enforcement logic call AI Guard at critical checkpoints and apply its verdict before anything proceeds.

In practice, the system looks at more than whether a tool call is technically allowed. It asks:

  • Did the user actually request this outcome?
  • Is the action consistent with the agent’s declared persona?
  • Is it within the agent’s permitted intents?
  • Does it violate a semantic constraint?
  • Is it appropriate for the user’s role?
  • Does the multi-turn session context support it?
  • Can the action be traced back to a legitimate request?

Uber also uses prompt provenance and evidence chaining to tie privileged actions back to what the user actually asked for. That adds a layer of defense against indirect prompt injection, goal hijacking, and unintended behavior.

The result is a simple rule:

A valid credential doesn’t make an action legitimate. A legitimate user request doesn’t make an action in scope. An agent may proceed only when the action satisfies the contract.

3. Continuous assurance: test the contract

The third layer closes the loop.

Uber captures end-to-end execution traces that link agent actions, tool calls, and guardrail decisions. They’re used for troubleshooting and auditing, with sensitive content minimized or redacted and access restricted by data sensitivity.

Uber can then replay recorded interactions against candidate guardrails and updated policies before enforcing them in production. Automated threat modeling, scenario-based penetration testing, and continuous AI red teaming feed back into risk scores, policies, model calibration, and guardrails.

This matters because agent behavior doesn’t sit still. Models change, tools change, attack techniques change, and business rules change. A behavioral contract can’t be a one-time compliance checkbox. It has to be versioned, tested, observed, and revised.

A concrete example: the refund agent

Two timelines comparing a refund agent: without a contract it issues a refund unchecked; with one, a policy check approves low-value refunds or escalates high-value ones to a human.

Picture a customer-support agent built to help people resolve billing issues.

Without a behavioral contract:

A customer writes, “I was charged twice. Please fix this immediately.”

The agent has a refund tool. It reads the request, finds a duplicate charge, and issues the refund. The action may even be technically authorized. But the agent may have stepped outside its intended role, skipped a required approval threshold, or acted on manipulated instructions hidden in a support ticket.

With a behavioral contract:

The agent is registered with a narrow intent: “Assist with refund eligibility checks and initiate low-risk refund workflows.”

Its constraints say:

  • It may retrieve order and billing information.
  • It may classify whether a case looks eligible for review.
  • It may draft a customer response.
  • It may initiate a refund only below a defined threshold.
  • It must escalate higher-value refunds for human approval.
  • It cannot modify account settings, issue credits outside its scope, or access unrelated customer data.

At the refund step, the proposed tool call is checked against the agent’s persona, intent, user context, and policy before it runs. If the action falls outside the contract, it’s denied or escalated.

The agent stays useful. It just can’t quietly turn itself into an unauthorized payments system.

Why this becomes universal

Agentic AI changes the security model because agents don’t just run predefined logic. They reason over untrusted content from users, webpages, documents, tools, and other agents, then turn that reasoning into real-world actions.

That brings risks traditional controls weren’t built for:

  • Prompt injection
  • Tool and memory poisoning
  • Goal hijacking
  • Behavioral drift
  • Hallucination-driven actions

As agents get access to production tools and sensitive data, identity and API permissions remain essential, but they stop being enough on their own. Uber’s position is that agentic systems need an extra semantic and behavioral control layer, one that decides not only whether an agent can act, but whether it should, given its purpose, the user’s request and permissions, and the session context.

That’s why behavioral contracts are likely to become a baseline requirement for mission-critical enterprise agents. They turn agent governance from an aspiration into something the system actually enforces.

The practical playbook

You don’t need to copy Uber’s whole platform to adopt the underlying principle. You do need to put behavioral contracts at the center of how you design agents.

Start with ownership

Every agent needs a named owner, a business purpose, and a risk classification before it ships. If nobody owns it, nobody can answer for what it does.

Write intents, not just prompts

“You are a helpful support agent” isn’t a spec. Define the outcomes the agent may pursue:

  • “Check refund eligibility.”
  • “Draft a response to a billing inquiry.”
  • “Escalate high-risk cases.”
  • “Retrieve order status for the requesting customer.”

Then spell out what it may not do.

Treat tools as privileged capabilities

Catalog every tool, MCP server, API, and data source, and tie each one to a purpose. An agent shouldn’t have a tool just because a developer added it. It should have it because the contract requires it.

Put policy at action boundaries

Check sensitive actions before they execute, not only at the initial prompt. The checkpoint that matters most is often the tool call, the moment an agent goes from reasoning to consequence.

Fail closed

"Decision tree showing that when an AI agent lacks identity, policy, or contract data, it fails closed and takes one of three paths: deny the action, escalate to a human, or fall back to a safe workflow."

If identity, policy, context, or contract data isn’t available, the agent shouldn’t guess. It should deny, escalate, or fall back to a safe workflow.

Make governance replayable

Record execution traces and test proposed guardrails against real interactions before you enforce them. That helps teams tell genuine risk from false positives without learning the lesson in production.

Design for iteration

Contracts should evolve. New tools, new risks, new attack patterns, and new business rules should trigger a review, not a silent expansion of what the agent can do.

The real governance trade-off

The debate over agentic AI usually gets framed as control versus capability. That framing is wrong.

The real choice is between unbounded autonomy and trusted autonomy.

Unbounded autonomy makes impressive demos. It also makes agents that can be manipulated, misaligned, over-permissioned, and nearly impossible to audit.

Trusted autonomy makes agents that can reason, adapt, and help people, but only inside boundaries that are explicit, owned, tested, and enforced.

Uber’s experience points to a simple conclusion: the most effective mitigation is often the least glamorous one. Restrict agents to explicit intents and constraints that tightly govern what may happen and under what conditions.

The future of enterprise AI won’t belong to the agent with the fewest restrictions. It’ll belong to the one you can trust to do the right thing, again and again, under pressure, at scale.

The most capable enterprise agent isn’t the one that can do anything. It’s the one that knows exactly what it’s allowed to do.

Leave a Comment