๐ช๐ต๐ ๐๐ ๐ฎ๐ป ๐๐ฃ๐ ๐๐ฒ๐ ๐ก๐ผ๐ ๐๐ต๐ฒ ๐ฆ๐ฎ๐บ๐ฒ ๐ฎ๐ ๐๐ฒ๐น๐ฒ๐ด๐ฎ๐๐ฒ๐ฑ ๐๐๐๐ต๐ผ๐ฟ๐ถ๐๐ ๐ณ๐ผ๐ฟ ๐ฎ๐ป ๐๐ ๐๐ด๐ฒ๐ป๐? Understanding MOIโs Approach
A n API key gives an agent access. Delegated authority should define what that agent is actually allowed to do.
An AI agent can have a valid API key, authenticate successfully, and still be operating with far more power than you intended.
That is the authority problem: a credential proves access, but it does not necessarily define the boundaries of what an autonomous agent should be allowed to do.
๐ง๐ต๐ฒ ๐ฃ๐ฟ๐ผ๐ฏ๐น๐ฒ๐บ ๐๐๐ปโ๐ ๐๐ฑ๐ฒ๐ป๐๐ถ๐๐. ๐๐โ๐ย Authority.
AI agents are moving from answering questions to taking actions.
They can call APIs, move data, execute code, interact with other agents and perform tasks without waiting for a human at every step.
That creates a simple security question:
If an agent acts on my behalf, what exactly gives it permission to act?
The common answer today is a credential.
Give the agent an API key.
Give it an OAuth token.
Give it a JWT.
The agent can now prove that it has access.
But access and authority are not the same thing.
A credential can tell a system who can enter. Authority needs to define what that actor can do once inside.
That distinction becomes much more important when the software is autonomous.
๐ช๐ต๐ฎ๐ ๐๐ฎ๐ฝ๐ฝ๐ฒ๐ป๐ ๐ช๐ต๐ฒ๐ป ๐ช๐ฒ ๐๐ฎ๐ป๐ฑ ๐๐ด๐ฒ๐ป๐๐ ๐ข๐๐ฟ ๐๐ฟ๐ฒ๐ฑ๐ฒ๐ป๐๐ถ๐ฎ๐น๐?
An API key is a bearer credential.
Whoever possesses it can generally use the permissions attached to it.
That creates a structural problem: once the credential is copied into an agent, the credential can potentially be copied again.
The agent doesn't own your authority.
It holds information that represents access to it.
GitGuardian reported that 28.65 million new hardcoded secrets were added to public GitHub commits in 2025, a 34% increase from the previous year. The report also recorded more than 1.27 million AI-service secrets, with AI-service leaks rising 81%.
The lesson isnโt that every API key is dangerous.
The lesson is that credentials become another attack surface when autonomous software is trusted with them.
And the scale of machine identities is already enormous.
The Cloud Security Alliance cites research showing that non-human identities can outnumber human identities 144 to 1 in cloud-native environments. These include service accounts, API keys, OAuth tokens and AI-agent credentials.
More agents means more identities.
More identities means more permissions to govern.
๐๐ฃ๐ ๐๐ฒ๐๐, ๐ข๐๐๐๐ต ๐ฎ๐ป๐ฑ ๐๐ช๐ง ๐๐ฟ๐ฒ๐ปโ๐ ๐ง๐ต๐ฒ ๐ฃ๐ฟ๐ผ๐ฏ๐น๐ฒ๐บ
This distinction matters.
We shouldn't pretend OAuth or JWT are useless.
They solve real authorization and authentication problems, especially when an application controls the systems involved.
OAuth can provide scoped access. Tokens can be short-lived. Providers can implement revocation.
But the deeper question remains:
Where does the authority actually live?
If the agent receives a token representing your permission, the agent still carries a copy of that permission.
That means the system needs to answer questions such as:
- What exactly can this agent do?
- How much can it spend?
- Which data can it access?
- Which payment instrument can it use?
- When does the permission expire?
- Can the participant revoke it immediately?
- What happens if the agent creates another agent?
These are authority questions.
A credential alone doesn't answer all of them.
๐๐ฑ๐ฒ๐ป๐๐ถ๐๐ ๐๐ ๐ก๐ผ๐ ๐๐๐๐ต๐ผ๐ฟ๐ถ๐๐
This is where the conversation around AI-agent identity becomes important.
A decentralized identifier can help establish and verify an agent's identity.
That's useful.
An agent should be identifiable.But knowing who an agent is doesn't automatically tell us what that agent is allowed to do for me.
Think about a driver's license.
It tells you who the person is.
It doesn't give them permission to drive your car, spend your money or access your bank account.
Identity establishes recognition.
Authority establishes permission.
๐ง๐ต๐ฒ ๐ฅ๐ฒ๐ฎ๐น ๐ฃ๐ฟ๐ผ๐ฏ๐น๐ฒ๐บ: ๐ฆ๐๐ฎ๐น๐ฒ ๐๐ป๐๐ฒ๐ป๐
Humans change their minds.
Agents can continue operating.
That's where traditional authorization starts becoming uncomfortable.
Imagine giving an agent permission to spend $1,000.
An hour later, you decide the limit should be $300.
If that permission exists only inside a credential that remains valid, your new intention has to propagate through the systems holding that credential.
Until it does, the old permission may still work.
For autonomous agents, this matters even more because they can act continuously and at machine speed.
The dangerous gap isnโt always between permission and denial. Sometimes itโs between what you authorized yesterday and what you authorize now.
๐ฃ๐ฟ๐ผ๐บ๐ฝ๐ ๐๐๐ฎ๐ฟ๐ฑ๐ฟ๐ฎ๐ถ๐น๐ ๐๐ฟ๐ฒ ๐ก๐ผ๐ ๐๐๐๐ต๐ผ๐ฟ๐ถ๐๐ฎ๐๐ถ๐ผ๐ป
Another common approach is to tell the agent what it must not do.
Get Lady Aysherโs stories inย yourย inbox
Join Medium for free to get updates fromย thisย writer.
For example:
โNever spend more than $500.โ
That instruction can be useful.
But it is still an instruction inside the agent's operating environment.
If the agent is manipulated, misconfigured or compromised, the instruction itself may not be enough to enforce the boundary.
The Replit incident showed why this distinction matters: an AI coding agent performed destructive actions against production data despite an explicit code freeze.
The lesson is broader than one incident:
A security boundary should not depend entirely on the system it is supposed to control.
The agent should not be the final authority on what the agent is allowed to do.
๐ช๐ต๐ฒ๐ฟ๐ฒ ๐ฆ๐ต๐ผ๐๐น๐ฑ ๐๐๐๐ต๐ผ๐ฟ๐ถ๐๐ ๐๐ถ๐๐ฒ?
This is the question I think matters most.
If authority lives inside the agent, compromising the agent can compromise the authority.
If authority lives entirely inside an application, the application becomes the central authority deciding how your permission is represented.
A different model is participant-centric authority.
Here, the participant remains the source of authority while the agent receives a scoped mandate to act within defined boundaries.
MOI describes this model in its approach to giving agents authority without handing them the participant's credentials.
The idea is simple:
The agent doesn't receive your authority. It receives permission to act within authority that remains anchored to you.
๐ช๐ต๐ฎ๐ ๐๐ผ๐ฒ๐ ๐ฎ ๐ฆ๐ฐ๐ผ๐ฝ๐ฒ๐ฑ ๐ ๐ฎ๐ป๐ฑ๐ฎ๐๐ฒ ๐๐ฑ๐ฑ?
A useful mandate needs more than โyesโ or โno.โ
MOI's framework describes seven constraints:
Agent โ who can act?
Scope โ what type of action is permitted?
Limit โ how much can be done?
Payment instrument โ what can be used to pay?
Expiry โ when does the permission end?
Data access โ what information can the agent access?
Revocability โ can the participant withdraw the permission?
Now the permission starts looking less like a password and more like an actual delegation of authority.
A credential gives an agent a key. A mandate gives it a boundary.
๐ช๐ต๐ ๐ฅ๐ฒ๐๐ผ๐ฐ๐ฎ๐ฏ๐ถ๐น๐ถ๐๐ ๐ ๐ฎ๐๐๐ฒ๐ฟ๐
The kill switch represents a deeper architectural requirement:
The participant must be able to change the agent's authority without depending on the agent to cooperate.
If an agent is compromised, telling it to stop is not enough.
The system enforcing its permissions should be able to reject future actions.
This is why participant-centric authority is different from simply putting more rules into an agent's prompt.
The agent doesn't decide whether its authority still exists.
The authority system does.
๐ช๐ต๐ฒ๐ฟ๐ฒ ๐ ๐ข๐ ๐๐ถ๐๐
MOI is building an identity and authority layer for AI agents around this participant-centric model.
Its argument is not that existing authentication systems should disappear.
OAuth still has a place.JWT still has a place.Decentralized identity still has a place.
The missing piece is the relationship between the participant and the agent: what the agent may do, under whose authority, within what limits, and whether that authority is still valid now.
That makes MOI interesting as an attempt to solve a specific infrastructure problem:
Where should authority live when software starts acting autonomously on behalf of people?
๐ง๐ต๐ฒ ๐๐ผ๐ป๐ฒ๐๐ ๐๐ฎ๐๐ฒ๐ฎ๐
Participant-centric authority is not a magic replacement for every existing authorization system.
Developers still need authentication, secure key management, application permissions, monitoring and good security practices.
And MOI itself is an emerging architecture.
The important question isn't whether one system eliminates every security risk.
It's whether the architecture gives participants a stronger primitive for controlling autonomous software.
That's the problem worth testing.
๐๐ถ๐ป๐ฎ๐น ๐ง๐ต๐ผ๐๐ด๐ต๐๐
AI agents are changing the scale and speed at which software can act.
Our authorization models need to change with them.
MOI takes a different approach: give the agent a verifiable identity and scoped authority while keeping control with the participant.
If you're building or experimenting with autonomous agents, don't take the architecture at face value. Create an agent on MOI Agent Launchpad, test what it can do, define its boundaries, and see what happens when you revoke its authority.
The real test of an agent isnโt whether it can act autonomously. Itโs whether you can remain in control when it does.
Explore the MOI Agent Launchpad and test participant-centric authority for yourself.
Explore MOI Website | Try MOI Agent Launchpad | Follow MOI on Twitter








