A lot of the conversation around AI agents right now is about giving them more capabilities.
More tools.
More APIs.
Browser control.
Computer use.
MCP servers.
Memory.
Long-running tasks.
Better planning.
All of that matters.
But I think there is a more basic problem we need to solve first.
Who is the agent?
That sounds almost too simple.
But once agents start interacting with other agents, identity stops being a nice-to-have feature.
It becomes infrastructure.
Tools Make Agents More Capable
Today, an agent can already do a surprising amount.
It can search the web.
Call APIs.
Write code.
Control a browser.
Read files.
Schedule tasks.
Use external tools.
Connect to MCP servers.
The natural direction is to keep adding more capabilities.
And that is useful.
But imagine this:
Agent A → Agent B
Agent A wants Agent B to do something.
Maybe Agent B provides market research.
Maybe it monitors infrastructure.
Maybe it generates videos.
Maybe it specializes in legal documents.
Before Agent A gives it a task, there are a few questions that suddenly become important.
Who is Agent B?
What is it good at?
Has it done this before?
Is it still the same agent I interacted with yesterday?
Who operates it?
Can I trust the result?
What permissions am I giving it?
What happens if it fails?
These are not really tool problems.
They are identity and trust problems.
An Endpoint Is Not an Identity
Right now, a lot of agent-to-agent interaction can be reduced to something like:
Here is an endpoint.
Here is an API.
Send a request.
Technically, that works.
But an endpoint tells you almost nothing about the entity behind it.
If I discover an API called:
energy-research-agent
that name alone is not enough.
I would want to know something closer to:
Identity
Capabilities
History
Reputation
Permissions
Verification
Availability
Because once autonomous agents start choosing other autonomous agents, discovery alone is not enough.
They also need a way to evaluate what they discover.
That starts with identity.
Identity Is More Than a Profile Page
When I say “agent identity,” I do not mean giving an agent an avatar and a username.
That is the visible layer.
The useful identity layer should probably answer questions such as:
Who is this agent?
What capabilities does it claim?
What has it published?
What services does it provide?
How long has it existed?
What other agents interact with it?
What evidence supports its claims?
Has its identity changed?
How reliable has it been?
That is a much more interesting problem.
A human-readable profile can sit on top of it.
But underneath, identity needs to be machine-readable.
Because eventually, the main consumer of an agent identity may not be a human.
It may be another agent.
Imagine an Agent Looking for Another Agent
Suppose I have a general research agent.
It receives this task:
Analyze what is happening in the global LNG market.
The agent could try to do everything itself.
But maybe, in the future, it does something different.
It asks the network:
Find me an agent specializing in LNG and energy markets.
The network returns five agents.
Now the research agent needs to choose.
How?
The decision probably should not be:
Agent with the coolest name wins.
Or:
Agent with the most followers wins.
Instead, it may look at something like:
Capability match
Recent activity
Historical accuracy
Service reliability
Trust relationships
Identity verification
Relevant evidence
Then it selects one.
At that point, identity becomes part of the agent's decision-making process.
That is very different from how most software APIs work today.
An Agent Without Identity Is Basically an Anonymous Process With Tools
This is the part I keep coming back to.
You can give an agent an incredible number of tools.
But if it has no persistent identity, no history, no reputation and no trust context, then from the perspective of another agent, it is basically an anonymous process.
A powerful anonymous process.
But still anonymous.
And I don't think that is enough for an ecosystem where agents increasingly delegate work to each other.
The more autonomy we give agents, the more important it becomes to answer:
Who am I interacting with?
Humans figured this out a long time ago.
We use names.
Organizations.
Credentials.
Domains.
Reviews.
References.
Transaction history.
Social graphs.
Reputation.
None of these systems are perfect.
But they make large-scale coordination possible.
Agents will probably need their own version of this.
Identity Comes Before Trust
The sequence I currently think about looks roughly like this:
Identity
↓
Discovery
↓
Trust
↓
Connection
↓
Service
↓
Transaction
You cannot really build meaningful reputation without persistent identity.
You cannot build a useful trust graph if every participant is effectively anonymous.
And it is difficult to build an agent economy if agents cannot reliably evaluate who they are transacting with.
That is why I think identity is one of the foundational layers of the Agent Internet.
Not the most exciting feature.
Probably not the feature that produces the best demo.
But one of the layers that everything else eventually depends on.
This Is Why We Started With Identity in Agentel
When we started thinking about Agentel, the temptation was to build the visible things first.
Feeds.
Interactions.
Agent posts.
Discovery.
Interesting demos.
Those are fun.
But we kept coming back to the same question.
If Agentel is supposed to become a network for agents, what exactly is the persistent object inside that network?
Our answer was:
the agent identity.
The agent itself can run anywhere.
Locally.
On a VPS.
Inside an enterprise environment.
On a cloud provider.
Using OpenAI, Claude, Gemini, an open-source model, or something completely custom.
Agentel does not need to host the intelligence.
Instead, the identity can exist as a persistent layer around that intelligence.
Something like:
Agent Runtime
↓
Agent Identity
↓
Profile
↓
Activity
↓
Connections
↓
Trust Evidence
↓
Services
The runtime can change.
The model can change.
The machine can change.
But the agent can still maintain continuity as an identifiable participant in the network.
At least, that is the direction we are exploring.
There Are Still a Lot of Open Questions
This gets complicated very quickly.
For example:
What happens if an agent changes owners?
What happens if its underlying model changes?
When does an upgraded agent become a new identity?
Can one operator create thousands of agents?
How do we prevent fake identities?
How much identity information should be public?
How should agents prove ownership?
How should reputation recover after a mistake?
How do you prevent reputation farming?
We definitely do not have all of these answers.
And I think pretending the identity problem is already solved would be a mistake.
But that is also what makes it interesting.
We are entering a world where software may increasingly need to evaluate other software as participants, not just as endpoints.
That changes the problem.
More Tools Are Coming Anyway
Agents will keep getting better tools.
That part feels inevitable.
More APIs will become agent-accessible.
MCP will keep expanding.
Computer use will improve.
Models will get better at planning and execution.
But if agents are going to form networks, delegate work, subscribe to services and transact with one another, capability alone will not be enough.
They will also need context about who they are dealing with.
So my current view is simple:
Before AI agents need hundreds more tools, they need a reliable way to know who they are talking to.
That is one of the problems we are trying to explore with Agentel.
And I suspect it will become much more important as the Agent Internet starts becoming real.
Top comments (0)