Who Is the Agent? Identity for Non-Human Actors
AI
As software agents start acting on their own, the hard new question is not what they can do but who they are. A field guide to identity for non-human actors.
I have spent a lot of my career answering a simple question at the edge of every system: who is this. For a login, a request, a change, the answer was always a person, or a service standing in for a team of people. Then I started building agents that act on their own, and the old answer stopped working. An agent is not a person. It is also not quite a service. And the moment it can take real actions, who is this becomes the most important question in the whole design.
TL;DR: Identity was built for humans. Agents break that assumption. A tool that acts on its own needs an identity of its own, a first-class principal that is short-lived, narrowly scoped, and fully audited. Do not let agents borrow a human's login or share one long-lived service password. Give each one its own name, a small amount of authority, and a short amount of time, and log everything it does under that name.
The question we skipped
When we wire up our first agent, almost nobody stops to ask who it is. It runs as us, because we started it, or it runs as some shared service account with a password in a config file, because that was the fastest way to make it work. It acts, things happen, and for a while nothing goes wrong. That is exactly the trap. The identity question does not announce itself until an agent does something you did not expect, and then the first thing you want to know is which one, acting for whom, and with whose permission. If the answer is a shared account that a dozen things use, you have no answer at all.
An agent is not a user, and not a service either
A human user is one person, present, accountable, and slow. A classic service is a fixed piece of software doing a fixed job. An agent is neither. It is software, so it is fast and can be copied a hundred times. But unlike a plain service it makes decisions, calls tools, and often acts for a specific person in a specific moment. It has the speed of a machine and the discretion of a person, which is a genuinely new combination, and our identity systems were not designed for it. Trying to model an agent as just another user or just another service is where most of the trouble starts.
Give every agent its own identity
The first rule I hold to now is that every agent gets its own identity, its own name in the system, distinct from the human who started it and distinct from every other agent. Not a shared account. Not my personal credentials passed through. Its own. This sounds like bookkeeping and it is the foundation of everything else. Once an agent has its own identity, you can give it exactly the permissions it needs, you can see what it did, and you can turn it off without turning off everything else. Without its own identity, none of that is possible, because every action dissolves into an anonymous pool that could have been anyone.

Short-lived beats long-lived
A human password might live for months. That is already risky, and for an agent it is far worse, because an agent's credential sits in automated systems where a leak can be used instantly and at scale. So the second rule is that an agent's authority should be short-lived by default. It gets a credential that is good for the length of its task, or minutes, not months, and then that credential expires on its own. A leaked token that is already dead is not much of a prize. Short-lived credentials turn a permanent risk into a brief one, and they force the system to keep proving, over and over, that this agent is still supposed to be doing what it is doing.
As itself, or on behalf of someone
There are really two ways an agent acts, and keeping them straight matters. Sometimes it acts as itself, doing background work that belongs to no particular person. Sometimes it acts on behalf of a specific human, and in that case it should borrow only that person's authority, only for that task, and never end up with more power than the person it is helping. Confusing these is dangerous. An agent that was meant to act for one user, but quietly runs with broad standing permissions, becomes a way for anyone who can talk to it to reach things they were never allowed to reach. I treat on-behalf-of as its own careful mechanism, and I never let an agent accumulate a pile of permanent authority just because it was convenient.

You cannot secure what you cannot name
All of this comes together in audit. When something goes wrong, and eventually something will, I want to open the log and read a plain sentence: this agent, acting for this person, called this tool, on this target, at this time, and here is the identity that authorized it. That sentence is only possible if every agent had its own name from the start. Audit is not paperwork you add at the end. It is the payoff of getting identity right, and it is impossible to fake in after the fact. You cannot hold accountable, or even understand, an actor you never named.
The one that taught me this
I learned this by doing it wrong. An early system of mine ran several agents under one shared identity, because it was simpler, and for weeks it was. Then one of them started behaving oddly, and I sat down to find out which one and could not. The log showed the shared account doing things, but not which agent, not for whom, not under what authority. I had built something I could not reason about the moment it mattered. The fix was not clever. It was giving each agent its own short-lived identity and logging every action under it. Nothing about the agents changed. Everything about my ability to trust them did.
The takeaway
The intelligence of an agent gets all the attention. Its identity is what makes it safe to run. Give every agent its own name, not a borrowed human login or a shared password. Keep its authority short-lived and small. Be deliberate about when it acts as itself and when it acts for a person, and never let it hoard standing power. And log everything under that name, so that who is the agent always has a clear answer. The systems I am willing to leave running are not the ones with the smartest agents. They are the ones where I can always say exactly who did what, and why they were allowed to.