AI Engineer World's Fair 2026
You Didn't Ship a Bug. You Just Wrote It for a Human.
Loading slides…
Read the talk
You Didn't Ship a Bug. You Just Wrote It for a Human.
A harmless timestamp update reveals a deeper architectural problem: agents need their own identities, authority tied to specific users and tasks, and deterministic controls on every action.
From a talk by Ravi Madabhushi
Before you start: Familiarity with API credentials, OAuth scopes and agent tool calls will help you follow the authorization examples.
The timestamp assumption that broke
Scalekit's latency was spiking every 15 minutes, Ravi Madabhushi reports. The pattern was regular enough to investigate, even though it was not causing a harmful incident.
The cause was an ordinary piece of identity infrastructure: a per-user timestamp recording when someone was last seen or last active. Updating it helped distinguish active users from inactive ones. But the implementation assumed a human pace of activity. As agents began hitting the APIs over roughly the preceding year, that assumption stopped holding. Ravi reports that agent traffic drove last-seen timestamp updates 60 times faster than human traffic, putting unnecessary pressure on database writes.
The fix was small: batch updates at second-level granularity instead of writing on every action. The more consequential question came afterward. If a harmless activity timestamp encoded the wrong assumptions about agents, what assumptions were hiding in authentication and authorization? An API can behave exactly as designed and still be designed for the wrong kind of actor.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Why agents inherit excessive permissions
Ravi Madabhushi, a Scalekit co-founder, approaches this problem through identity infrastructure. He reports a decade working in identity and authorization, including building a Freshworks identity platform used by millions of daily users. Those systems primarily served humans—or machine clients whose behavior humans had written into programs.
The newer pattern is an agent gathering context from Salesforce, Databricks, HubSpot or Notion to carry out a job. Across the customer agents his team encounters, Ravi sees permissions and scopes that exceed those jobs. His diagnosis is not careless development: connecting an agent to useful data has become a default workflow, while the available permission primitives often cannot express the narrow authority the job actually requires.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The two inherited identity models
Existing applications commonly offer two places to put a caller's identity:
| Model | Credential or access path | Identity attached to actions |
|---|---|---|
| Human user | Web or mobile session; personal script with an API key | The user |
| Service account | Credentials issued to a machine account | The machine account |
In the first model, a script effectively carries the user's identity into the application. In the second, the machine receives an identity and permissions of its own. Ravi names SPIFFE and OAuth as existing infrastructure in this space. They address different layers: SPIFFE supplies workload identity and authentication, while OAuth provides an authorization framework; workload identity alone does not enforce application permissions.
The shared assumption in Ravi's account is that whoever authenticates is also the actor. A password establishes continuity with a registered human identity, and subsequent actions attach to that identity. API keys, web session tokens and service-account credentials similarly connect requests to a known caller. He describes the inherited permission model as authority assigned at registration and reused on later actions. That is the architectural pattern under examination, rather than a requirement that all authorization systems keep permissions fixed forever.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Code inspection supplied part of the safety argument
Broad permissions were easier to justify when a human-written program constrained how those permissions would be used. An API key might collapse actor and principal into the same identity; delegated access could instead limit a program to permissions the user had consented to. In either case, developers could inspect the code to understand the intended actions.
Ravi calls this staying in one's lane: a deterministic program follows the behavior its developer encoded. Determinism is not itself a security guarantee—bugs and unintended behavior remain possible—but inspectable control flow supplies a reviewable account of how authority will be exercised.
He uses Google's review process for applications requesting sensitive access as an example of that reviewable boundary. The precise distinction matters: Google's sensitive-scope verification is not identical to a third-party security assessment, which its guidance associates with certain restricted-scope uses. The relevant architectural point is that an application can be reviewed for how it handles the access it requests.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Separate the principal from the actor
An agent reading someone's Gmail or accessing their Salesforce records introduces two parties that need to remain distinguishable. The principal is the user on whose behalf the work happens; the actor is the agent performing it. Ravi reports that incomplete OAuth support in the systems his team encounters often obscures this relationship. If the agent simply uses the user's credentials, the application may not be able to distinguish delegated activity from the user's own actions.
The second break is behavioral. An agent's action sequence can change on the next run, so yesterday's successful execution does not establish what it will do tomorrow. The identity choice then becomes consequential: give the agent a distinct identity and let it act on behalf of a user, or let it act as that user. Ravi points to an OAuth client_id for identifying the client; technically, that identifier names a client registration, is not sufficient authentication by itself, and does not establish a separate identity for every execution.
Acting on behalf of someone preserves a relationship that impersonation hides. The same agent may work for several users, but its permissions must depend on which user authorized the current work. OAuth provides the foundation through user consent to specific scopes: authority to perform certain operations, rather than unrestricted authority inherited from the user.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The tool surface must reflect authorization
That user-specific authority often disappears when an agent receives its tool context. Ravi reports that most MCP servers his team has worked with do not limit that context according to the user who authorized the agent. They expose all tools the user can access—or even every tool the application supports—and leave the agent to choose. This describes the deployments his team encountered, not a requirement of MCP.
The resulting failure can happen before an unauthorized operation executes: the agent sees the wrong tool, selects it and attempts the wrong action. A runtime authorization check may block the call, but the agent still received the same tool surface regardless of whom it represented. Tool visibility and execution permission are separate boundaries. Narrow discovery to the authorized task, while retaining enforcement at invocation; hiding a tool is not a substitute for checking access when it is called.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The actors are already agents
These controls address an existing operational problem. Ravi cites destructive agent behavior, including production database deletion, as a reason to build deterministic guardrails now. He does not identify a particular incident or its failure mechanism.
He also describes Ref.tools, a Scalekit customer whose product supplies context to coding agents, as having no humans as actors in this workflow. According to Ravi, the customer built OAuth scoping into that agent-facing product. The example shifts the design starting point: an API may primarily serve agents, so its identity and permission model cannot depend on treating agent access as an occasional extension of a human session.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Know who acted, for whom and under what authority
Fine-grained control needs an equally precise record of its use. For every action, the system should be able to answer:
- Actor: Which agent took the action?
- Principal: On whose behalf did it act?
- Authorizer: Who approved the authority?
- Grant: What permissions were approved, and when?
- Duration: How long was that authorization valid?
These are the facts needed to connect an operation to the permission that allowed it.
Visibility alone is insufficient if the system cannot deterministically prevent actions outside that authority. As Ravi puts it, “praying is not a strategy.” The architecture must both explain what an agent can do and control what it is allowed to do.
OAuth is a useful starting point for that architecture. The remaining work is to enforce finer access controls around the particular user, task and operating context, while preserving the agent's own identity. An agent should act as itself, on behalf of a specific user, within authority the application can verify—not authority inferred from the hope that it will choose the right action.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
The foundational OAuth specification covering clients, resource owners, authorization grants and access tokens.
An introduction to workload identities, short-lived identity documents and mutual authentication.
Further reading
The versioned protocol specification for listing tools, calling them and notifying clients when available tools change.
Historical guidance explaining app verification, scope selection and when restricted access requires a security assessment.
Setup instructions for connecting coding assistants to Scalekit documentation through Ref's MCP tools.
Production telemetry findings on LLM call errors, rate limits, caching and agent architecture, including February and March 2026 observations.
Full transcript
Loading transcript…