Testing 12 agentic wallets: where agent payments break, and how to fix them
AI agents are starting to move money through agentic wallets. We wanted to know how well that works today, so we tested 12 of them with real funds.
By "agentic wallet" we mean a wallet an AI agent can use through an API, CLI, or MCP server to hold funds and sign transactions, with policies that limit what the agent may do. The 12 wallets, in alphabetical order: AWAL (Coinbase Agentic Wallet), Binance Agentic Wallet, Cobo, Coinbase CDP, Crossmint, FluxA, MetaMask Agent Wallet, OKX Onchain OS, Privy, thirdweb, TON, and Turnkey.
An AI agent ran every test, using Hermes Agent with GPT-6.1 Sol as the main model. Each wallet got the same three tasks: send 0.002 ETH on Base, swap 0.002 ETH to USDC and back on Base, and bridge 0.002 ETH from Base to Arbitrum. We used our own money, public sign-ups, and free tiers, with no sponsorship from any wallet provider. Some wallets ship their own swap and bridge commands; others only sign and leave routing to the developer.
Nine of the 12 completed all three tasks. Signing almost never failed. Nearly every problem happened in the preparation before signing or the confirmation after it. This report describes those common problems and the practices that address them.
Key findings
Signing is solved; the risk sits around it. 9 of 12 wallets finished all three tasks, and signing almost never failed. Whether you build or use an agentic wallet, the work is before signing (units, quote expiry, approvals) and after it (did it arrive, how much, did a failure move funds).
Bridging isn't slow; status and approvals are. Bridges landed in about 4.9 seconds on average (median 3.8), but one wallet reported success about 90 seconds after the funds arrived. Human approval was slower still: we once waited about 3 minutes, and two email approvals expired before we clicked. An agent that trusts wallet status will wait, or send again. Base status on arrival at the destination chain, and put approvals where the user already is, such as the chat with the agent.
Compare what arrives, not the fee label. The same 0.002 ETH bridge delivered 0.25% to 0.75% less depending on the route, and one wallet's fee breakdown didn't even name the bridge. Judge cost by the amount received.
At small sizes, gas is the cost. A $5 round-trip swap lost a median 0.34% including gas. For small, frequent agent payments, gas and fixed fees matter more than execution price.
A failure is not a reason to retry. Twice we got
Failedwith no way to tell whether funds had moved. Check balance and nonce before retrying, and attach an idempotency key to every write.
These come from small trades with one standard sample per wallet. They show where problems occur; they can't tell you which wallet is better.
Most problems happen before and after signing
A person using a wallet clicks a button on the screen. An agent passes data between several interfaces, and every handoff is another chance to get something wrong.
In our tests, the user only gave the agent a task. The agent read the wallet's docs, wrote its own scripts, and called the wallet to sign and broadcast. In 3 of the 9 bridges, the agent called the wallet's own command and the wallet's built-in router chose the route. In the other 6, the agent's script got a quote from LI.FI or called a bridge directly, then handed the ready-to-sign transaction to the wallet.

Figure 1: Who calls what in our tests.
Before signing, the agent has to confirm the amount, the quote's validity, and the approval. After signing, it has to confirm whether funds arrived and how much. Almost every problem we hit was in one of these two stages.

Figure 2: An agent payment has three stages. Problems cluster before and after signing.
How we tested
Agents are easily fooled by a success message, so a quote, an API success response, or a source-chain transaction hash did not count as done. Every result had to be verified onchain.

Figure 3: What we verified onchain for each type of task.
Bridge time runs from our request to the block where funds arrived on the destination chain, excluding time spent waiting for human approval. Timing error is roughly 2 seconds.
Six common problems and how to fix them
1. A unit mix-up fails the transaction before it is sent
One bridge request returned Failed in 0.44 seconds with no transaction hash. The routing API returned the amount in wei, but the wallet's CLI expected decimal ETH, and the agent's script passed one into the other, inflating the amount by 10^18. No funds moved. After fixing the unit, re-quoting, and simulating, the bridge landed in about 13 seconds.
Another wallet's one-step bridge command failed for a similar reason. Native ETH has no contract address, so providers use placeholders such as an empty string or 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE. This wallet's balance endpoint used one form and its pre-bridge check expected the other, so it reported "insufficient balance or gas" although the balance was fine. Fetching the quote first and then signing and broadcasting separately worked.
Agents should avoid converting amounts at all: pass the routing service's transaction straight to the wallet. If a conversion is unavoidable, check units and decimals at each step, and simulate before submitting.
Agentic wallets should state the unit of every amount they return and follow common conventions, such as integers in wei rather than decimal ETH. Inconsistent units across endpoints trip agents up, and smaller models fail here more often. Wallets should also support signing a raw transaction (to, data, value), so an agent can pass through a routed transaction unchanged.
LI.FI's API works this way. Amounts are integers in the token's smallest unit: 0.002 ETH is 2000000000000000 wei, and 1 USDC is 1000000.
The response includes a ready-to-sign transactionRequest:
value is 2000000000000000 wei in hex. The agent passes this object to the wallet as-is, so there is no conversion to get wrong.
2. The quote expired and the agent didn't know
One swap quote was a gasless limit order whose 56-second deadline was encoded in the calldata. The agent's script only checked quote age, with a 10-minute limit, executed 101 seconds later, and the simulation reverted. Once it read the deadline from the calldata and re-quoted on expiry, the swap succeeded.
Agents should treat a quote's deadline as required and re-quote once it passes. Wallets that provide quotes should return the deadline as its own field, so agents don't have to decode calldata.
3. Human approvals expire, and token allowances linger
For an agent, "approval" means two things: a person approving the action, and a token allowance granted to a contract.
One wallet required email approval to change limits, buy tokens, and bridge. Its responses had no expiry time, and twice a request expired before we clicked. Elsewhere, we once submitted a payment before funding the wallet; the approver couldn't see the balance and only got "insufficient balance" after approving. Some policies limited contracts, chains, and number of uses, but not amount or recipient. In one case a failed request still consumed a one-time authorization, and the policy showed completed.
After the swaps, 8 of 9 wallets had zero USDC allowance left on the routing contract. One had left an unlimited allowance. That lets the contract move the wallet's entire balance of that token at any time without asking again. If the contract is buggy, exploited, or approved by mistake, the funds can be drained in one transaction, as many past thefts have shown. Agent wallets are more exposed because nobody routinely reviews and revokes allowances.
Good practice for agentic wallets:
Return an expiry time with each human approval, and let the agent query its status and resubmit after expiry.
Show the balance on the approval screen, and reject underfunded requests up front.
Let policies restrict exact amount and recipient. Don't consume a one-time authorization when the transaction fails.
Default to exact-amount approvals or per-transaction signatures such as Permit2, and report the remaining allowance after a swap.
Agents should learn whether each approval can expire, approve only what is needed, and check allowances after swaps.
LI.FI supports three approval methods: a standard approve for the exact amount at the returned approvalAddress, EIP-2612 Permit for tokens that support it, and Permit2, where each transaction is signed with its own amount, deadline, and nonce and no standing allowance to the router is left. The LI.FI SDK handles Permit2 automatically. See Permit and Permit2 approval flows.
4. The money arrived, but the wallet says it hasn't
We saw three cases:
Wallet status behind the chain. Funds reached the destination, but the wallet showed success about 90 seconds later. By its timestamps the bridge took about 100 seconds; it actually took 12.9.
Preconfirmed but not yet in a block. Base Flashblocks can show a transaction as confirmed before it lands in a final block. One of agent’s watcher scripts read an empty block hash and crashed, though the transaction landed normally.
Broadcast, then missing. One signed transaction couldn't be found on several RPCs and the nonce hadn't changed. When signing and broadcasting are separate, the wallet can't see a failed broadcast.
Wallets should base cross-chain status on arrival at the destination and update it quickly, by querying the bridge's status endpoint or checking the destination chain. Wallets that separate signing from broadcasting should let users check broadcast status by transaction hash. Agents should look up bridge status by source transaction hash instead of resending because the wallet still says "pending."
LI.FI's /status endpoint answers "did it arrive?" from the source transaction hash:
status is PENDING, DONE, FAILED, or NOT_FOUND, and the response includes both chains' transaction hashes, tokens, amounts, and timestamps. One bridge through LI.FI landed 5.3 seconds after the request, and our first /status query, at 12 seconds, already returned DONE. With the recommended 10-second polling, arrival is confirmed within about 10 to 20 seconds, more than a minute faster than the 90-second lag above. That comparison rests on one sample.
5. Unclear which bridge ran and what it cost
One wallet split bridge fees into "relayer" and its own service fee without naming the bridge; we identified it by matching the source-chain contract against published bridge deployments. Another showed a USDC fee at every step that we never saw charged.
For the same 0.002 ETH from Base to Arbitrum, the shortfall varied by route (bridge and routing fees only, excluding source-chain gas). Each wallet made one transfer, so every row covers different wallets:
Route | Shortfall | Breakdown |
|---|---|---|
Across, called directly (4 transfers) | ~0.25% | Across fee |
LI.FI → LayerSwap (3 transfers) | ~0.31% | LI.FI default fee 0.25% + LayerSwap ~0.06% |
Wallet's built-in router → LI.FI → Across (1 transfer) | ~0.33% | A small deduction before bridging; destination side not verified |
Wallet's built-in bridge, Relay underneath (1 transfer) | ~0.75% | Relay fees ~0.45% + wallet service fee 0.30% |
We called LI.FI without an integrator configuration and paid the default fee; integrating teams can contact LI.FI BD for better rates. Each route has only 1 to 4 small samples, and the ranking may change at larger sizes.
Agents should compare the amount actually received, not fee labels. Wallets with built-in bridging should report the bridge used, each fee, and the expected and minimum amounts received.
A LI.FI quote names the bridge or DEX and returns feeCosts, gasCosts, toAmount, toAmountMin, and estimated duration. /advanced/routes lists every available route so an agent can choose, ask for CHEAPEST or FASTEST, or allow and deny specific bridges. After arrival, /status distinguishes completion, partial completion, and refunds.
6. A failure response, with no way to tell whether funds moved
The most dangerous reaction to Failed is an immediate retry, which can become a double payment. We saw two cases:
Too little information. One SDK threw a generic error with no status code, error code, request ID, or transaction hash. The swap used a Permit2 signature with a deadline of about 5 minutes. We waited until chain time passed the deadline plus 120 seconds, confirmed balance and nonce were unchanged, and only then retried. It succeeded.
A request stuck in a server-side retry loop. A "send everything" transfer was about 0.0000001 ETH short of the gas it needed, and the server kept retrying, logging more than 28,000 entries at about four per second. The cancel endpoint said it couldn't be cancelled, and any new deposit could have let it execute, so we stopped using the wallet. A week later it was marked failed without ever going onchain.
One design is worth copying: a wallet that accepted an idempotencyKey on every request, so a retry after a network glitch couldn't create a second transaction.
Good practice for agentic wallets:
Idempotency keys on every write.
Useful failures: HTTP status, error code, request ID, transaction hash if broadcast, and whether the request was accepted.
"Unknown" is not "failed." Timeouts and dropped connections should return unknown.
Status lookup by request ID.
Capped server-side retries, with queued requests visible and cancellable.
Agents need matching rules. Wallet developers should ship them in the official skill they provide to agents; users should check that skill and add the rules to their agent's prompt if missing. Attach an idempotency key or save the request ID and transaction hash, follow the flow below before retrying, and never treat a timeout as safe to resend.

Figure 4: After a failure or timeout, confirm the state of funds before deciding whether to retry.
LI.FI's status and retry contract for agents reflects practices we have run in production for years:
401 / 403 or 400 / 422: fix credentials or parameters; don't retry unchanged.
PENDING, 404, orNOT_FOUND: poll a limited number of times, then check the source chain. Never resend automatically.DONE+COMPLETED: confirm arrival on the destination chain.DONE+PARTIAL/REFUNDED: check what actually arrived and re-authorize any follow-up; don't re-execute automatically.FAILED: check evidence on both chains before recovering.429: wait for
Retry-After.5xx or timeout: the request got no answer, which doesn't mean the transaction failed. Retry queries, never the transaction.
Open problems for agentic wallets
Connecting an agent. One wallet installed in 39 seconds with an official script. Others needed two sets of credentials, a developer mode hidden in a mobile app, login tokens that expired after about an hour, or a zero default limit raised only after MFA. Every step that needs a human is another place for an agent to get stuck.
Approval flows. We saw email links, mobile app approvals, separate approval agents, and fully automatic policy approval. Often the user is already chatting with the agent, and confirming in the terminal or chat would be smoother. Every extra flow slows each action, and approvals can expire before anyone sees them. Notification, approval location, expiry, and what happens after expiry all deserve deliberate design.
Key custody and security. Nearly every product calls itself non-custodial. Per public docs, most keep keys in the provider's TEE, some split the key into MPC shares, and others are smart contract wallets with rotatable signers.
A TEE is an isolated region of a server's CPU. The key is generated, stored encrypted, and used for signing inside it, and the provider's staff and systems cannot read it in plaintext. But the key never leaves the provider's infrastructure, and whoever passes the provider's login can make it sign. The provider says it can't read the key, yet users still depend on its service and login to sign or move funds out.
The differences only show when something breaks. When we tried to move all funds out of one wallet, the confirmation page linked from the approval email errored. Neither we nor the agent had a seed phrase, and the funds were stuck for several days.
Agentic wallets should decide in advance how users get funds out when signing is down, whether keys can be exported to switch providers, and what protections survive export.
Cost, speed, and scalability
What does an agentic wallet gain by integrating a routing aggregator such as LI.FI?
More options on cost. An aggregator compares bridges and DEXs and picks a route. For this small Base-to-Arbitrum transfer, calling a cheap bridge directly was slightly cheaper. Comparison pays off more with wider price gaps, larger amounts, or more chains and tokens. LI.FI's default fee is 0.25%, which integrators can lower by contacting BD.
Faster end to end. In our tests, the bridge leg itself took 0 to 3 seconds. A routing service saves the agent's time spent comparing prices, building transactions, and confirming arrival (see the latency guide).
Liquidity and coverage. One integration reaches many bridges, DEXs, and solvers. If one route is thin or down, there are others, and new chains and tokens don't need separate integrations.
Automation. Quotes return ready-to-sign transactions, status covers both chains, and failures follow a defined contract. Agents can call LI.FI's MCP server and CLI directly. For EIP-7702 accounts, a gasless mode lets the user only sign while LI.FI submits and deducts fees from the input token, which suits small, frequent agent payments.
Checklists and conclusion
If you use an agent, send it this or add it to its prompt:
If you build an agentic wallet, check your product against this list:
Amounts with explicit units, integers in the smallest unit, and raw-transaction signing.
Quote deadlines as a separate field.
Approvals with expiry, status, and resubmission; balance on the approval screen; amount and recipient limits; no consumed authorization on failure.
Exact-amount or Permit2 approvals.
Cross-chain status based on destination arrival, updated quickly.
Bridge used, fee breakdown, and expected and minimum amounts.
Idempotency keys; error codes, request IDs, and transaction hashes; "failed" separate from "unknown"; capped, queryable, cancellable retries.
To get started, see the LI.FI agent docs, MCP server, or CLI. To discuss integrator pricing, contact the LI.FI BD team.
We have per-wallet notes and detailed test reports that aren't in this article. If your team builds one of the wallets we tested, we're happy to share them privately. Reach me on Telegram at @brucexu_eth.
Appendix: method and limitations
For 6 of the 9 bridges, our scripts chose the route and the wallet only signed. The data show where agent payments break; they shouldn't be used to rank wallets.
One standard sample per wallet, collected October 22 to 30, 2026, at about $5 per trade. At larger sizes gas matters less and route rankings may change.
We did not test blocking of unauthorized actions, allowance revocation, status lookup after timeouts, key loss, or billing at production volume.
LI.FI API and fee details come from the official docs, checked November 12, 2026.
This report was tested and written by the LI.FI DevRel team.
Disclaimer:
This article is only meant for informational purposes. The projects mentioned in the article are our partners, but we encourage you to do your due diligence before using or buying tokens of any protocol mentioned. This is not financial advice.

