As CEO of Haia Finance, you position the platform as a “control plane for programmable money.” What does a truly non-custodial AI financial experience look like for someone using it every day?
Honestly, everyone gets hung up on custody, and to me that’s the easy half. Non-custodial in the strict sense just means your keys stay with you and the platform can’t move your money on its own. Fine, most teams can do that. The bit that’s actually hard is authority. Because the second you put an AI agent next to those keys, the question isn’t really who’s holding them anymore. It’s what the agent is allowed to do with them, and whether you can see that and change it whenever you want.
So, the thing I actually care about is not “I hold my keys” as some slogan. It’s this. You give the agent a small, bounded piece of authority, and at any point you can look from the outside and see exactly what it’s allowed to do and flip it off if you don’t like it. The agent goes and does the boring multi-step stuff. You just keep a live view of what it can touch.
And here’s where I think the black-box vaults get it wrong. The spending limit lives inside the model’s prompt. But a limit that lives in a prompt is really just a polite request. In a proper non-custodial setup, the limit lives in the account itself and is enforced by code. It’s the difference between a hard daily cap your bank sets for you, and you texting a friend “hey please don’t spend more than 500.” Same intention, totally different outcome when it matters.
Describe how tools like session keys and account abstraction change the way everyday people navigate messy, multi-step DeFi strategies. Where do you draw the line between agent freedom and absolute control over your funds?
Session keys and account abstraction matter for basically one reason: they drag the enforcement point out of the prompt and put it into the account. That one move is what makes handing work to an agent feel okay instead of terrifying.
The way I think about the line is, let the agent do whatever it wants on execution, and pin it down hard on authority. Let it grind through the eight ugly steps a human hates, approve, bridge, swap, deposit, rebalance, unwind, without bugging you every time. But you wrap all that freedom in a mandate with a few fields that really bite. A scope, so it can only touch the strategy you pointed at. An aggregate cap, so everything it spends under one task stays under one ceiling. An expiry, so the thing just dies on its own. And a way to revoke it that you can actually watch from outside, so you can kill it and be sure it’s dead.
People keep underestimating two factors: first one is aggregate-spend. A per-transaction cap does nothing against a stream of tiny, perfectly valid payments and machine-speed finance is basically a firehose of tiny payments. The second is nastier because it’s quiet. Revocation fails silently. I had an agent once run five days on stale authority nobody had re-confirmed. No error, nothing. Some callbacks just kept quietly refreshing an old token and it all looked fine. It cost me a weekend. Now put a funded wallet behind that same little bug and it’s not a weekend anymore, it’s real money walking out.
At Haust Network you’re building a custom zkEVM L2 around native yield and AggLayer. How does Haust unify liquidity across EVM chains differently than traditional bridges, and what part does Polygon’s AggLayer play?
Let me reframe this one, because it’s bigger than Haust Network. People describe fragmentation like it’s a clunky bridging UX. It is a canonical representation problem. A normal bridge mints a wrapped copy of the asset on the far side. So, three bridges and now you’ve got three versions of the same dollar, three shallow pools, three whitelist slots everyone fights over. I watched this play out on Aptos, wrapped USDT pools sitting at something like 30% APR, and that number isn’t opportunity, it’s a sign of how broken the thing is. It’s the wrapped-token wars showing up as yield.
What AggLayer does is go after the disease instead of the symptom. Rather than forking the asset every time it moves, you keep one canonical asset behind a unified escrow, and you lean on ZK proofs to keep the cross-chain state honest. The asset stays one asset across chains. That’s the whole thing, and it’s why my rule from actually building this stuff is pretty blunt: never build custom bridges.
It is worth telling your readers that the banks have the exact same disease, just one floor up. It’s the cash island problem. A JPMorgan tokenized deposit isn’t fungible with a BNY one, even though both are literally US dollars sitting at a regulated bank, because each one mints its own onchain money and nothing connects them. Retail wrapped-token mess and institutional cash islands, it’s the same illness at two different altitudes. Whoever keeps one asset as one asset across chains is the one who wins.
Haust introduces mechanics like Haustoria to route high-yield programs automatically to end users. From a protocol design perspective, how do you bake native yield into a Layer-2 without falling into unsustainable token printing or serious smart contract risk?
Here the whole trick is to be honest about where the yield is actually coming from. People use one word, yield, for two completely different things. One is yield as emission, where you’re printing your own token to pay holders. That’s a treadmill, and it stops the day you stop printing. The other is yield as routed real return, where the money comes from something real, lending spreads, LP fees, staking, tokenized T-bills, and the protocol just quietly routes it to the user by default.
Native yield done right is honestly more of a plumbing decision than a money decision. You bake in the rails that carry real, outside yield to the user automatically, so they earn without hunting around for pools or babysitting a position. And the test is almost embarrassingly simple. Switch off the token incentives and see if anything’s still paying. If the answer is nothing, well, it was emissions in a costume the whole time. That same 30% APR trap from the liquidity question comes right back here in a new outfit.
On the contract-risk side the discipline is to write as little novel code as you can, and above all no novel bridges, because that’s where the ugliest exploits live. Lean on audited standard primitives, borrow the shared security of the settlement layer instead of rolling your own cryptography. And steal one rule from market structure while you’re at it. Any yield instrument needs a real price anchor and a way to correct itself. Without that, you have tokenized a promise, and a promise pays yield right up until the moment it doesn’t.
Looking at the roadmap for both Haia and Haust over the next 12 months, what is the single biggest bottleneck standing in the way of mainstream crypto adoption?
Throughput and user experience are finally being fixed. Cheap blockspace, zkEVMs, account abstraction, and user-friendly wallets are all arriving more or less on schedule. The layer nobody’s really building is authority. The last mile between a token, or an agent, and an actual enforceable right. That, for me, is the single biggest bottleneck, and the funny thing is it shows up in both of my worlds wearing the same face.
On the agent side we’ve built machine-native money and left machine-native authority written in plain human language. In BlackRock’s own reference workflow for agents paying agents, every layer is a protocol or a token except one, the permission, which is just a sentence in a prompt. We engineered the money and left the permission as text. That gap is exactly where the first real agentic losses are going to come from, some delegation that was technically valid and nobody actually meant to grant.
On the tokenization side the same bottleneck just wears a regulatory coat. Adoption there is gated by permission, not technology. Banks go first because they already hold the licenses, and startups die at the regulatory stage, roughly nine out of ten of the hundred-plus concepts I’ve worked through, because a token means nothing until there’s an off-chain legal structure that makes it enforceable. Both are really the same story. The tech is ready and the authority layer is underbuilt, precisely because it’s less visible and less investable than the money layer.