A user types: send 1,000 USDT to a friend on Polygon. Their USDT is on Ethereum.
There are several reasonable ways to do that. Bridge it with CrossCurve. Use stablecoins the user already holds on Polygon. Swap through 1inch. Each route has its own fee, its own wait and its own way to fail. A language model will pick one and describe it with full confidence, whether or not anything checked the liquidity. In a chat app that is a wrong answer. In a wallet it is a loss.
This is the everyday problem in Haia, an AI finance OS I work on as fractional CTO through Innowise. One interface covers wallets, transfers, cross-chain swaps, limit orders, portfolio and DeFi strategies, and it has replaced about seventy separate crypto app interfaces. Before we picked a model, we had to decide where a model is allowed to act at all.
The model drafts, and that is all it does
The agent answers with a structured operation rather than prose: a swap, a transfer, a limit order or a deposit, with chain, asset, amount and route as typed fields. If the output does not parse into a known operation with valid fields, there is nothing to run.
That is what I mean by a deterministic agent. The model underneath is as probabilistic as any other, and the same request can come back worded differently twice. What it can hand over is a short, fixed list of operation types, each with fields we can check.
No keys on our side
Haia stores no private keys, no seed phrases and no funds. There are no hot wallets and no shared custody. People connect the wallets they already use through WalletConnect, and every transaction is signed by the user in their own wallet or bank app, not by Haia.
This removes a whole class of failures. If a model misreads a request, if a prompt injection slips through, if our own code has a bug, there is still no server-side key that could move money. A bad draft can only end up on the user’s screen. The one exception is delegation, and it is deliberately narrow; more on that below.
Anything with an exact answer goes into code
Between the model and the screen sits ordinary code. Does the user hold this asset on this chain? Does the amount fit the balance? Is there enough liquidity on the preferred route, and if not, which fallback route takes over? Each of these has an exact answer, so there is no reason to ask a model for it.
The prompt still matters. It is where the agent learns about the user’s wallets and assets, which is how “send 500 USDC to grandma” becomes a real address from the address book and a real balance. Context makes the draft more accurate. What a draft is allowed to do stays the same.
| Question | Decided by |
|---|---|
| What does the user want? | The model, from the request and the wallet context |
| Which operation, chain, asset and amount? | The model drafts them; the user can change any of them |
| Is the asset there, and does the balance cover it? | Code |
| Which route, and what if liquidity is short? | Code, including the fallback route |
| Does it run? | The user, by signing in their own wallet |
| What may an agent do unattended? | The user, through a scoped permission they can revoke |
The screen is the last guardrail
Every operation is shown before it runs: what will happen, on which chain, through which protocol. Every field can be edited. In the Innowise case study I put it as “every action is editable and transparent before it goes on-chain”.
Being able to edit matters in practice. When the model gets the amount or the chain wrong, the user corrects one field and signs, instead of rephrasing the request and hoping the next draft comes out right. Agent-level audit logs keep every operation traceable afterwards.
Delegation with a limit
Some intents cannot wait for a signature. Take a conditional strategy: if ETH reaches $8,000, find the chain with the best Aave yield, deposit ETH, borrow $1,000 against it and reinvest. The price may cross that line at three in the morning, when nobody is awake to confirm anything.
For this, Haia uses account abstraction. The user grants the agent a scoped, temporary permission for specific actions and specific amounts, and can revoke it at any time. It works more like a card with a spending limit than like handing someone your PIN.
New agents, same boundary
Features are added as MCP modules: a portfolio rebalancer, a KYC validator, a tax analyzer, and agents that white-label partners deploy themselves. Each module gets its own scoped context and isolated permissions.
This is what lets us add agents quickly. A module can be as clever as it likes inside, but its output still goes through the same typed operation, the same checks and the same signature.
After the demo
The proof of concept took nine days. By August 2025 the first thousand beta testers were using it, and on 28 November 2025 Haia OS went live. Most of the work in between was invisible: routing LLM requests, caching what can be cached, controlling concurrency, and keeping data consistent across Ethereum, Polygon, Base and BNB Chain. None of it shows in a demo.
If you are starting one
Decide where the model may act before you choose the model. Make its output a typed object with a short list of allowed operations. Move every rule you can state exactly into code. Show the user the exact transaction and let them change it. If the agent has to act alone, give it a scoped permission with a limit and an expiry, never a key.
The system behind this pieceHaia: AI finance OS