AI agents are starting to move from suggesting crypto actions to preparing and executing them.
In October 2026, MetaMask published a quickstart for its Agent Wallet, while Ledger introduced Agent Intent, a model in which agents can prepare actions but fund-moving operations wait for user approval on a hardware signer.
These products differ in implementation, but they expose the same architectural question:
Where should autonomy stop?
The dangerous combination: untrusted input plus financial authority
An AI agent consumes information from places that may be adversarial.
It can read:
- websites;
- messages;
- API responses;
- documents;
- token metadata;
- market data;
- instructions from other agents.
Some of those inputs can contain prompt-injection attempts or misleading data.
If the same agent also holds unrestricted signing authority, an attacker may be able to turn content into a financial action.
That is a fundamentally different risk from a chatbot giving a bad answer.
Treat the agent as a proposer, not the root of trust
MetaMask’s own security guidance for agentic wallets describes a useful model: the agent should be treated as an unfamiliar transaction proposer rather than a trusted signer.
Ledger’s October Agent Intent announcement takes a similar architectural direction. The agent can prepare operations within policy, while actions moving funds are designed to wait for approval on the hardware signer.
The security principle is broader than either product:
The system that decides what it wants to do should not automatically be the only system allowed to authorize that action.
This is separation of duties applied to software agents.
Approval must contain meaningful information
"Human in the loop" is not automatically safe.
If the user sees only "Approve?" without meaningful transaction details, the approval is ceremonial.
A useful authorization boundary should let the signer verify at least:
- destination;
- asset;
- amount;
- network;
- relevant contract;
- unusually broad permissions;
- whether the action changes future policy.
The approval interface must also be independent enough that a compromised agent cannot simply rewrite what the user sees.
This is why trusted displays remain important.
Policy changes deserve stronger controls than routine transactions
Agent wallets increasingly support spend limits, allowlists and operating modes.
Those controls are useful only if the agent cannot silently remove them.
MetaMask documentation, for example, describes approval requirements for requests that fall outside Guard Mode policy and for changes that loosen wallet limits.
This is a key design principle: changing the safety policy should require at least as much authorization as spending under that policy.
Otherwise an attacker does not need to steal funds directly. They only need to disable the limit first.
Bounded autonomy can still be powerful
A secure architecture does not require a human to approve every low-risk read operation.
Agents can safely automate many tasks:
- monitor balances;
- calculate staking allocations;
- prepare unsigned transactions;
- compare quotes;
- alert on validator health;
- identify policy violations;
- simulate transactions.
Even some financial actions can be automated under narrow, enforceable limits.
The important distinction is whether the consequences are bounded.
An agent that can rebalance up to a small daily limit between two approved contracts is a different risk from an agent with unrestricted treasury authority.
Organizations need separate agent wallets
A corporate treasury should not be the default wallet for experimentation.
Agentic systems should begin with isolated wallets and limited balances.
A mature deployment can define:
- maximum daily outflow;
- approved counterparties;
- approved contracts;
- approved networks;
- transaction-size thresholds;
- mandatory human approval conditions;
- emergency disable controls;
- logs of every proposed and approved action.
Permissions can expand only after the system demonstrates predictable behavior.
Key custody remains a hard boundary
The agent should not need access to a seed phrase.
It should not receive raw private keys through prompts, environment variables or configuration files that are also accessible to its tools.
Where possible, signing should occur in a separate component with scoped permissions.
That could be a hardware signer, HSM, MPC policy engine or another isolated authorization layer.
The exact technology matters less than the separation.
What this means for GLOV
Agentic wallets are not just a product trend. They are an upcoming governance problem.
Organizations will need to decide:
- which agents can propose actions;
- which policies constrain them;
- who can change those policies;
- which actions require a human;
- where keys live;
- how an agent can be revoked.
Those are the same questions GLOV already applies to multisig, custody architecture and operational governance.
GLOV Secure can help organizations design authorization boundaries around digital assets without taking custody of the assets themselves. GLOV Consulting can help teams define where automation is useful and where authority must remain independent.
The most useful rule is simple:
Let agents automate work. Do not let one compromised reasoning process become the only thing standing between an attacker and irreversible authorization.