Uber — agent platform, MCP, gateway

Platform thinking: identity before intelligence

Uber's public writing on AI gateways and agent platforms emphasizes identity, authorization, and centralized policy over raw model capability. Internal tools are exposed via controlled interfaces (including MCP-shaped patterns); agents inherit who the user is and what they may do from the platform — not from prompt pleading.

Contrast with early course agents: one API key, all tools available, trust the model to behave.

Reading goals

From Uber agent identity / AI gateway materials, extract:

• Agent identity — service account vs user-delegated authority
• Tool authz — scopes per role, audit on mutating calls
• Gateway responsibilities — rate limit, DLP, model allowlist, MCP registry
• Developer experience — teams ship MCP servers; platform registers them

Document in industry/uber/notes.md with comparison table: demo agent vs platform agent.

Callout — MCP as internal RPC: Uber-style platforms treat MCP servers as owned services behind auth, not arbitrary user plugins.

Mock identity and authz in lab

Implement without corporate SSO:

{
  "actor_id": "user_123",
  "roles": ["support"],
  "scopes": ["orders:read", "refunds:issue_under_50"]
}

Pass via header X-Agent-Context or signed JWT stub. MCP server and agent host both validate before tool execution — defense in depth.

Authz matrix example:

Model proposing forbidden tool → middleware block (eval module guardrails pattern).

Wire agent + MCP with authz

Flow:

1. Gateway attaches identity context to request.
2. Agent loads tools from MCP registry filtered by scopes.
3. Each call_tool includes actor context; server enforces policy.
4. Audit log: {actor, tool, args_hash, decision}.

Compare to your hand-rolled agent from agent and skills modules — write gap_analysis.md: what you lacked, what you added.

Failure modes

• Confused deputy — agent uses admin credential for user request. Fix: per-user delegated tokens.
• Scope creep — new tool forgets authz check. Fix: codegen or central policy registry.
• Over-filtered tools — model hallucinates capability user lacks. Fix: clear "not permitted" tool messages.

MCP registry lifecycle

Platform teams maintain registry: server name, owner, scopes, health URL, version. Agents resolve tools at startup from registry — not hard-coded localhost ports. Portfolio stub: registry.yaml listing MCP servers with scope tags; agent refuses unregistered server IDs.

Audit and compliance

Regulated industries require immutable audit log of tool calls — append-only store, retention policy from privacy module. Mock audit satisfies lab; notes.md should describe what Uber-scale retention and SIEM integration look like.

Developer velocity vs central gate

Central gateway slows individual hackers, speeds org-wide safety — design review tension from synthesis module applies. Document when teams may bypass gateway in dev (never prod) with local-only keys.

Putting it together in practice

ShipAI treats this lesson as executable curriculum, not reading alone. Before marking complete, trace one real request through your portfolio stack and label where this lesson's concepts apply — even if the first pass is messy. Document what broke in the module README; that gap list becomes your next sprint.

Compare your implementation against the industry callouts cited earlier without copying their scale. Name one deliberate simplification you kept (mock auth, SQLite not Postgres, single-region deploy) and one simplification you refuse to ship without (no eval gate, no trace on mutating tools, no fail-closed guardrail on exfil cases). That contrast is what interviewers and graders look for.

Callout — Teach back: Explain this lesson's core tradeoff to a peer in five minutes without slides. If you cannot, re-read the failure modes section and add an example from your own run logs.

Common questions and misconceptions

"Is this overkill for a side project?" Side projects can skip pieces; capstones and production cannot skip knowing the pieces exist. You may waive cost accounting in v1 but your architecture diagram should still show where it would attach.

"Should I rewrite from scratch?" Extend what you built in prior modules — graders reward evolution, not parallel unused folders. Link file paths in your checklist.

"Which metric matters most?" The metric tied to user harm or revenue: policy violations, failed refunds, silent wrong answers — not vanity leaderboard scores.

Extension paths after the micro-project

After the micro-project passes smoke check, choose one extension aligned with your capstone pillar: tighten eval coverage, add a chaos or red-team case, or wire observability into SSE streams. Extensions belong in BACKLOG unless scope freeze explicitly includes them — avoids capstone death by optional polish.

Engineering problem (staff framing)

Study public engineering patterns around Uber: Agent platform / gateway. Rebuild the idea, not scraped proprietary text — focus on transferable architecture.

Diagram — Uber pattern (conceptual)

flowchart LR
  Apps-->Platform-->MCP/Tools-->Models

Precise definitions & mental model

Extract 3 transferable patterns from Uber's public tech narrative on Agent platform / gateway; map each to a ShipAI module artifact.

Tradeoffs — when to use what

Failure modes (interview + on-call)

Cargo-culting brand names without metrics; inventing fake citations; cloning UI not architecture.

Production & OSS practices

Write a lab README: hypothesis, architecture diagram, eval, cost model, what you'd ask their eng in an interview.

Micro-project: Agent + MCP + mock authz

Ship:

1. Uber reading notes + gap_analysis vs prior agent.
2. MCP server with ≥2 tools, authz enforced server-side.
3. Agent host passing identity; tools filtered by scope.
4. Demo: support role blocked on high-value refund; admin succeeds.
5. Audit JSONL for allow/deny decisions.

Acceptance: same prompt, different roles → different tool outcomes with audit trail.

Checklist

• Platform reading notes committed
• Mock identity propagated agent → MCP
• Authz matrix enforced on mutating tool
• gap_analysis.md vs earlier agent
• Audit log for tool allow/deny