By Atul Tulshibagwale, Board Member of the OpenID Foundation and Head of Identity Strategy at CrowdStrike.
Why the developer workstation is the hardest place to secure an AI agent
The developer workstation has almost overnight become one of the most privileged places an AI agent can live in the enterprise. Highly damaging recent attacks have brought urgency to securing the "AI-powered developer". Coding agents and IDE copilots run with the developer's shell, source repositories, cloud CLI sessions, and package registry credentials. They connect to Model Context Protocol (MCP) servers that reach into ticketing systems, CI/CD pipelines, and production data. They read untrusted content (issues, pull requests, dependencies, web pages, tool output) and act on it with the developer's authority, at machine speed, often under an "allow always" approval clicked weeks ago.
An autonomous, nondeterministic actor with ambient authority (power it can use simply because of where it runs, not because it was granted for the task at hand) is both highly resourceful and a security risk, steerable by any text it reads. What makes agents useful also makes the ambient authority they hold dangerous. A developer with production access rarely touches it by accident; an agent that hits an obstacle will look for another path, using whatever it can reach. Incidents like PocketOS highlight the risks of ambient authority.
Much of the current thinking on agentic identity, including Sean O'Dell's excellent post, You Already Have the Pieces. Now Build It, focuses on server-side agents running in infrastructure you control, where every outbound call can be forced through a gateway. The developer environment breaks those assumptions.
This post, the first of at least two, explains how. It is written for security and IAM decision makers and practitioners who need to understand the problem before devising solutions.
Four ways the developer environment is different
Figure 1 shows a typical AI-enabled developer environment today. The numbered points match the sections below.

Figure 1. The AI-powered developer today. No enterprise policy point sees all of these calls.
1. Agents inherit everything the developer can reach
A coding agent doesn't need to steal credentials. It runs as the developer. It inherits the terminal session, the SSH agent, cloud CLI tokens, Git credentials, and the personal access tokens (PATs) that often sit in plaintext in MCP configuration files. When it runs, say, git, kubectl, or a cloud CLI, the calls look exactly like the developer typing them. The enterprise identity provider (IdP) issued many of these credentials once, at sign-in or consent, and never sees them used. Every downstream system believes the agent is the developer.
It also inherits the developer’s data: a Downloads folder full of exports and temporary files, .env files, shell history, browser profiles, and cloud storage mounted as a local drive. None of it is related to the task, and all of it is readable, exfiltratable, and a potential source of injected instructions.
File permissions, process sandboxing, and scoped sudo rules could constrain what the agent can reach, but few organizations configure them on developer workstations, where they tend to get in the way of the work.
2. Some tool calls never touch the network
Local MCP servers commonly run over stdio, as child processes of the agent, so tool calls travel over local inter-process communication that no gateway or IdP will ever see. The MCP specification itself advises stdio servers to take credentials from the environment rather than use the OAuth flow. In practice, that often means a long-lived PAT in a config file. When such a server calls a SaaS API, only the endpoint's process tree can tell you that an AI agent originated the call rather than a "dumb" developer tool. Endpoint telemetry is the only lever, and only on devices you manage. But contractors, open-source contributors, and BYOD policies mean many developer laptops are unenrolled or only lightly managed, so even endpoint visibility can’t be assumed.
3. Some tool calls never touch the endpoint
The opposite case is just as common. Some AI providers broker "remote connectors" from their own cloud: the user configures the connector in their account, the provider stores the OAuth token, and its service calls the MCP server directly, even when the user is working in a desktop app on a managed laptop. Endpoint controls are blind to those calls, and the MCP server sees just another OAuth client, "the AI provider, on behalf of user X". Because the connector lives in the user's account, it also follows them to mobile apps and unmanaged browsers. The enterprise's only decision point was at the time of consent. After that, the provider holds a refresh token, and nothing re-evaluates whether the user, device, or session is still trustworthy.
4. The confused deputy holds its own keys
Prompt injection hidden in a README, a code comment, an issue, a dependency, or a tool's response can confuse an agent that is already empowered - the classic confused deputy. In the LLM context window, the developer’s intent and an attacker’s instructions look the same. An authorization system that only sees the resulting request doesn’t have visibility into what caused the request. Worse, most agents today are their own OAuth clients, holding access and, often, refresh tokens for the remote MCP servers they use. A hijacked agent doesn't need a policy-checked tool call to cause harm. It can use its token directly, from any process, against any API the scopes allow, or hand it to something else entirely.
Where tool calls originate determines what you can see
Most developer environments contain all of these patterns at once. Classifying agent surfaces by where their tool calls originate shows which of your controls can see them at all.
Agent surface | Where tool calls originate | What the enterprise can typically see | What it typically can't |
|---|---|---|---|
Local MCP servers (stdio or localhost HTTP) used by coding agents, IDEs, and desktop assistants | The endpoint | Endpoint telemetry, on managed devices | Any network or identity control; credentials are often long-lived PATs in config files |
Local agents calling remote MCP servers | The endpoint | Endpoint and network telemetry; the IdP at sign-in | Whether a call reflects the user's intent; use of the agent-held token outside any tool call |
Remote connectors brokered by an AI provider's cloud | The provider's cloud | The IdP at consent time; resource-side logs | The device, client, or agent instance behind a call; sessions on unmanaged devices |
Cloud-hosted or background coding agents (in provider or enterprise sandboxes) | The provider's or your infrastructure | Whatever the hosting environment logs | Often, a distinct workload identity; credentials are frequently provisioned as static secrets |
No single product covers every row. Endpoint detection is blind to row three and a network gateway to row one, while an IdP that decides only at sign-in or consent is absent at the moment of use in all four.
The root of the problem: credentials in the wrong place
In every row, the agent, or the provider service acting for it, holds reusable credentials that were issued once and are used many times, with no enterprise decision at the moment of use. Standards like AuthZEN moved access decisions out of applications and into managed, policy-driven services. AI agents have pulled those decisions right back into the application through standing credentials, and placed them inside the most manipulable component in the system. Three things follow.
- Authority is ambient. The agent's reach is the developer's reach, not what the task requires.
- Decisions are made at grant time, not at call time. Conditional access runs at sign-in or consent. A week later, when an injected instruction drives a destructive call, no policy point is in the path, and the human approval that might have stood in for one became "allow always" long ago.
- Revocation is slow and fragmented. When a device or session turns risky, that knowledge sits in one system, while the tokens held by the agent, local MCP servers, and the provider's cloud keep working until they expire. The OpenID Shared Signals Framework (SSF) and Continuous Access Evaluation Profile (CAEP) can propagate revocation events, but they aren’t widely deployed.
None of this is a failure of any one product. It is what happens when a new kind of actor is dropped into an identity model designed for humans and deterministic applications.
Questions to ask about your own environment
Before evaluating any solution, it helps to know which of these problems you actually have:
- What is running? Which AI agents, IDE extensions, MCP servers, skills, and models are on developer machines, and who approved them?
- What can the agent reach? How many PATs, API keys, and refresh tokens sit in agent and MCP configuration files, and what can each of them reach? Beyond credentials, can the agent read everything the developer can, or is it confined to the task at hand?
- Who holds the tokens, and where can they be used? For each MCP server and SaaS application your agents use, is it the agent, the AI provider's cloud, or a component you control? Would a stolen token work from another machine?
- Where is the decision made? Does anything evaluate individual tool calls, with their arguments, at the moment they are made, including calls to local MCP servers that never leave the machine?
- How fast can you revoke? When a device or session turns risky, how long until every token an agent can use stops working?
- What is the blast radius? If a prompt injection hijacked one of your developers’ agents today, which production systems and sensitive SaaS applications could it reach?
If the honest answers are "we don't know", "the agent", "when the token expires", (or for API keys “never”) and “everything the developer can reach”, you are where most enterprises are today.
What comes next
The good news is that we probably don't need to invent a new security discipline. The building blocks largely exist in standards the identity community has already developed. The IETF WIMSE working group’s AI Identity Management System draft (AIMS) assembles existing standards, such as OAuth and OpenID Connect, token exchange (RFC 8693) and identity assertion grants (ID-JAG), SSF and CAEP for revocation, and AuthZEN for externalized authorization to address AI agent security. What’s missing is an opinionated way to apply them where their assumptions are hardest to meet: on the developer’s endpoint, in the AI provider’s cloud, and everything in between. In Part 2, I’ll propose one, starting from a design rule that departs from the usual model: agents should never hold keys or OAuth tokens.
About the OpenID Foundation
The OpenID Foundation (OIDF) is a global open standards body committed to building trusted identity ecosystems. Our mission is to lead the global community in identity standards that are secure, interoperable, and privacy respecting. Founded in 2007, we are a community of technical experts. The Foundation's OpenID Connect standard is now used by billions of people across millions of applications. More recently, the FAPI security profile - built on OAuth 2.0 - has become the standard of choice for interoperable Open Banking and Open Data implementations, while OpenID for Verifiable Credentials specifications are underpinning a new generation of digital wallets. Today, the OpenID Foundation's standards are the connective tissue that enable people to assert their identity and access their data at scale, the scale of the internet, enabling "networks of networks" to interoperate globally. Individuals, companies, governments and non-profits are encouraged to join or participate. Find out more at openid.net.
