Non-human identity is the phrase of the moment, and almost everyone defines it a little differently. Here is how I have come to think about it, machines, agents, and the humans they work for, and the two rules I think are non-negotiable if they are going to coexist.
Everyone tells this story their own way
I have been listening to a lot of involved discussions on non-human identity lately, and it is striking how differently security practitioners describe it. Everyone’s background shapes the story they tell to make the idea easier for themselves to hold. I have done the same exercise, and what follows carries its own biases, the ones that come with experience and outlook.
One line of thought is that non-human identity is brand new: that we need to name these identities and invent novel ways to fit them into the existing ecosystem. That splits the community. Some practitioners hold that there is nothing new here, machines have always interacted with other systems. A larger group believes they are net-new, needing new protocols and new ways to assign identifiers. Some want to understand it, some want to map it onto what they already run, and some see an opportunity.
Machine identities are not new
On that first question, I do not think machine identities are new. Machines are the fundamental building blocks of every system. Sometimes they manage data; sometimes they take actions, directly, or on behalf of someone else. That someone else may be a human at the other end, or another machine. (I am using “machine” as a generic term for a process, to keep things simple.)
So what is an agent?
What is genuinely new is the paradigm. Most existing machine interactions were deterministic: the behaviour was exact code execution against known requirements. Now the same machine talks to an LLM, shares data with it, and takes instructions from it to carry out. That is a different thing altogether.
The combination most people agree to call an agent is a machine paired with an LLM, where the LLM acts as the brain. An agent is often treated as an atomic unit, but switching LLMs on the fly, depending on the task, is one of the core capabilities for efficiency, control and economics. So it is fair to label a machine that is integrated with an LLM and executing that LLM’s instructions as an agent.
The friction, part one: identity at agent scale
There is real value in using LLMs to automate and improve a large chunk of work. It also brings its own risks. The dynamic nature of the decision-making makes an agent behave like a human, and like a human, it can be productive, and it can make mistakes.
For an agent to do anything in the ecosystem it needs access and permissions, and to regulate and audit what it does it needs an identity. Agents can spawn more agents, which makes the identity problem harder; and their ephemeral nature makes it harder still. Naively minting an identifier for every short-lived agent would burn through transactional storage quickly. That particular problem is non-functional, and it can be mitigated.
The friction, part two: access, privacy, and who a service is for
The bigger challenge is access, privacy and security. Most of the web earns its revenue by building services that are valuable to people, online businesses as extensions of brick-and-mortar ones. To make products easy to discover and use, we built UX for humans; to let systems talk to each other, we built APIs. In effect, companies served humans and machines differently, and some chose to serve only one segment. That choice of who a service is for is one of the most important parts of this whole discussion.
Web scraping was the controversial version of it: the UI was meant for humans, but there was value in it that other companies wanted, so they mimicked human behaviour to gather the data. Agents bring the same tension back, sharper. Website owners are now trying to keep agents out, and even providers who offer APIs are reluctant, because they were not built for the agentic case. The hardest flows are the ones where an agent acts on behalf of a human: granular, delegated access is difficult, and more often than not an API key is simply mapped to the same privileges as the human user.
WebFrolic’s take
Agents are here to stay, and they bring real value. But we need to update some rules and conventions to make these interactions clearer and safer. A few, at a high level:
- Identification. A machine integrated with an LLM should explicitly declare its capabilities, and should be attributed differently from an ordinary machine. That is what lets guardrails actually be effective.
- Respect the boundaries. A resource owner makes a conscious choice about who they serve. If a service does not offer API access, using the UI to mimic a human and get in is not just unethical, from a security standpoint I would argue it should be treated as a crime. That sounds extreme, but we have to be explicit about it.
- Delegated access and granular authorization. Agents are most valuable when they are helping a human, and in that case they should act on the access the human delegates to them. Delegated access, for a fixed time and with reduced scope, is key to avoiding unwanted effects.
These are non-negotiable if all the different kinds of identity are going to coexist and work together. It is also the model we build toward: identity for AI agents, delegated access through Connections, and workload identities for the machines underneath.
