Insights

AI Security

Your coding agent still works for the engineer who left

Background coding agents often run on a developer's personal token and are never provisioned as identities of their own, so they keep working after that developer leaves. A one-tab inventory with an owner, scope, token, and offboarding date closes the gap.

November 12, 2026 · 6 min read

Your coding agent still works for the engineer who left

A background coding agent authenticates as whoever set it up, and it keeps doing so after that person is gone. Daniel Lozovsky, who builds identity and governance for enterprise AI agents, made that point in a post on November 8: "When the developer who configured it changes teams or leaves the company, the agent continues running under that developer's personal token."

That is one practitioner's warning, not a survey, and I am not going to attach a number to it. I am writing about it because it describes a gap that small HealthTech engineering teams are especially likely to have. They adopt developer tools quickly, they have no separate identity team, and their offboarding checklist was written for people.

The difference between a tool and an agent

Lozovsky's framing is simple. "A developer tool stops running when the engineer closes the laptop. A background coding agent with repo access and task permissions does not." He describes agents that poll queues, spawn sub-tasks, and open pull requests while everyone is offline.

The identity problem follows from how these agents get set up. In his words, "Nobody creates an IT ticket to provision a background agent. Nobody reviews which repositories it can touch." The engineer pastes a personal access token into a config, the agent starts working, and from then on everything it does looks, to your source control system, like that engineer did it.

That causes three problems at once. The agent has whatever access the engineer had, which is usually more than the task needs. Its actions are mixed into the engineer's history, so you cannot separate them in an audit. And when HR offboards the engineer, the checklist disables their laptop, email, and SSO account, but a long-lived token stored in an agent's config may not depend on any of those. Whether it survives depends on how your source control platform ties tokens to accounts, and most small teams have never checked.

Why a health system will care

If your product handles PHI, a health system's security review will ask who can change your code and how you remove access when someone leaves. Today the honest answer for many teams is "people, plus some agents we haven't counted."

Lozovsky describes the failure he is worried about: an agent compromised through "dependency confusion or prompt injection in an issue tracker" becomes "an untracked entity operating inside your core codebase with valid credentials." I would add the quieter version. Nothing gets compromised, but a departed engineer's agent keeps merging dependency updates into a repository that feeds production, and nobody can say who approved it. Either way, the gap is the same: no owner on record.

The one-tab inventory

You do not need a platform to start. You need one spreadsheet tab with one row per agent. These are the columns I would use.

  • Agent: the tool and a short name for this instance, such as "dependency bot, billing service."
  • Where it runs: a hosted service, a CI runner, a developer's machine, a cloud VM.
  • Human owner: the person accountable for what it does today, plus a backup owner.
  • Identity it runs as: the engineer's personal account, a shared service account, or its own non-human identity.
  • Token: type, where it is stored, when it was issued, and when it expires. "Never" is an answer worth flagging.
  • Scope: which repositories, which permissions (read, write, open pull requests, merge), and whether it can trigger CI or deployments.
  • Data it can reach: production configuration, secrets, anything that could contain PHI, or only code.
  • Offboarding trigger: what event removes it (owner leaves, project ends, a fixed date) and the date of the last review.

Fill it in by asking each engineer what they have running, then cross-check against your source control platform's list of active tokens and installed apps. The cross-check matters. Agents that nobody mentions are the ones the inventory exists to find.

Rules that make the inventory stay true

An inventory decays unless something forces updates. Lozovsky proposes three rules, and they fit a small team with one adjustment.

His first rule: "Every autonomous coding persona must be provisioned as a distinct non-human identity in your central directory, complete with an owner and an offboarding lifecycle." His second: no shared service accounts for development agents, and "every tool must bind to a named engineer so code attribution remains auditable."

Those two can read as a contradiction. Is the agent its own identity, or tied to an engineer? I read them together: the agent gets its own identity, so its actions are separable in logs and its access can be revoked without touching a person's account, and that identity has a named human sponsor recorded in the directory. The sponsor changes when people move. The identity does not silently inherit a person's access.

His third rule is to block any pull request from merging "if the approving review came from the same agent identity that submitted the code." That is the same separation I argued for in the agent should never hold write access to its own monitor. An agent should not be the only check on its own work.

For a small team, I would add two practical habits:

  1. Put "agents and tokens you own" on the offboarding checklist, next to the laptop. Before an engineer's last day, every row where they are the owner gets a new owner or gets shut down.
  2. Give every agent token an expiry date and review the tab when tokens come up for renewal. A token that expires forces a conversation. A token that never expires lets everyone forget.

Where to start this week

Lozovsky ends his post with a question worth taking literally: "How many active access tokens belong to tools whose sponsors left the company six months ago?" Open your source control organization settings, export the list of active tokens and installed apps, and compare it to your current staff list. Any token tied to someone who has left is your first row.

If the inventory turns up agents running as personal accounts, the related exercise in the three questions you can answer for an employee and not for your agents is the next step: for each one, write down what it is allowed to do, on whose behalf, and who approved it. If no one can answer those for a given row, turn that agent off until someone can.