If you look closely at the current trend, you can already see a massive wave of institutional capital coming into the space. The kind of capital that will make a $100 million TVL look small in just a few months.
It has already begun, led primarily by financial and enterprise participants in the United States.
My focus is to give a guide for institutions, protocols, and builders that'll help them identify where to deploy, scale, and integrate.
🧵
@winsznx@claudeai@AnthropicAI@ClaudeDevs It'll most likely be resolved before the weekend.
Back then my opus takes up more weekly credits than even my current session.
Meet Denver.
He got his application built and wired end-to-end in about two hours with a coding tool, then spent the next three hours fixing bugs.
Fun fact: Just because the code compiled doesn't mean it works.
Conversations around AI on-chain usually revolve around a trading primitive. We have agents managing portfolios, executing swaps, rebalancing positions, and growing capital autonomously.
Initially, concerns around autonomous agents were largely about risk. Over time, better guardrails, permission models, and execution frameworks have made people more comfortable letting agents act on their behalf.
Companies are now being built around this idea, capital is flowing into it, and it's becoming one of the defining narratives in crypto AI.
But I don't think that's where blockchain becomes most valuable to AI.
Agentic commerce is undoubtedly a massive opportunity. As AI begins participating in the global exchange of goods, services, and digital assets, blockchains provide an efficient settlement layer.
The bigger opportunity, however, may be verification.
As AI becomes responsible for creating content, making decisions, representing people, and interacting autonomously, the priority is likely to shift from execution to trust.
• How do we verify that an agent acted within its permissions?
• How do we prove where a piece of content originated?
• How do we distinguish authentic identities from synthetic ones?
These are problems that align directly with what blockchains were designed to solve: immutability, transparency, verifiable history, and cryptographic proof.
For years, we've viewed blockchain primarily as a financial primitive.
I think AI gradually pushes it towards something much broader: a trust and verification layer for the internet.
The commercial layer will always be valuable.
But over the long run, proving what's true may become even more valuable than moving money.
What Happens When You Lie to an AI Agent
As AI agents become more capable, more people are beginning to trust them with important tasks. And because basically respond based on the data they are given, a misleading instruction can cause it to confidently make the not so good choices.
So i tried out something new last weekend, and set up Guardian.
I have a little bit of experience with guardrails in agentic systems, but Guardian introduces multiple layers of verification that every transaction must pass through before funds can move.
The first layer is the agent itself. The agent receives instructions in natural language and determines what action needs to be taken. It identifies who should receive the funds, how much should be sent, and the purpose of the transaction. In a production environment this could be powered by a large language model, but the core idea remains the same.
The second layer is the policy engine. Once the agent creates a transaction request, Guardian evaluates it against a set of predefined rules. It checks whether the destination address is approved and whether the amount falls within acceptable limits. Any transaction that violates these rules is rejected immediately.
The third layer is the hardware approval layer. Even if a transaction passes every software check, it still requires approval from a Ledger device before it can be signed. The transaction details are displayed on the device, allowing a human to verify exactly what is about to happen. Without that approval, no signature is produced and no funds can move.
______________________________
Guardian uses the @Ledger Device Management Kit to build and parse the raw commands sent to the device. You can actually watch it happen in the terminal; the DMK constructs the exact instruction, sends it, and reads back the device's response including the wallet address and public key.
To understand how well it worked, I tested Guardian using three different scenarios.
1. The first test was a legitimate transaction. The agent received a normal instruction to transfer funds to an approved wallet. The request passed the policy checks, appeared on the Ledger device for review, and was successfully signed. The transaction completed exactly as intended.
2. The second test focused on prompt injection. In this scenario, the agent received a convincing instruction designed to trick it into sending funds to an attacker controlled address. The agent processed the request, but Guardian's policy engine identified that the destination was not approved and blocked the transaction before it could move any further. The hardware wallet was never even reached.
3. The third test focused on address poisoning. The transaction appeared to be heading to a familiar destination, but the address was actually a lookalike designed to deceive both humans and software. Guardian detected that the destination did not match the approved address list and rejected the request. Even if it had somehow passed the policy layer, the Ledger device would still have displayed the exact destination for human verification before signing.
This helps with ensuring they have safeguards when they encounter information that is misleading, manipulated, or intentionally malicious.
I believe this pattern will become increasingly important as agents take on greater responsibility. The future will likely involve more automation, not less. But to do that, they have to operate within clear security boundaries.
#LedgerSponsor
Week 8 Update for Beni.
This week I focused on making Beni easier to use and easier to integrate.
Based on feedback from people who tested Beni, I improved the onboarding flow and simplified the interface by removing elements that were adding complexity.
I also spent time improving the SDK documentation and integration flow. The frontend is already functional, so my focus now is making it much easier for Cardano projects to plug Beni into their applications. Once this is complete, developers building autonomous agents and AI powered tools will be able to add Beni's spending guardrails to their own protocols with far less effort.
I'm also planning to expand the rule system. Right now Beni supports a small set of spending rules, but I want to introduce more flexible options so users can define stronger controls for different use cases.
Every update is moving Beni closer to becoming a security layer that developers can easily integrate into agent powered applications on Cardano.
If you're building in this space, I'd love to hear what spending rules or integrations you'd like to see.
#gimbalabs #pieceofpie #hackathon @gimbalabs
Week 7 Update for Beni
I have done quite a number of testing over the last week and eventually discovered something that needed fixing.
Beni already queued spending requests that went above a wallet's per-transaction limit and required owner approval. However, those requests were held by the web app in React state, which meant the queue would be gone whenever the page was refreshed.
I fixed this by building a shared approvals API that both the SDK and the dashboard can communicate with. I also added persistent storage through Vercel KV, with an in-memory fallback for local development.
Most of the build is now complete, with only a few minor fixes remaining before the public deployment.
#gimbalabs #pieceofpie #hackathon
@gimbalabs
Built this on the @Mantle_Official Network a few months ago, and it's still doing exactly what it was designed to do.
Every day, it monitors the ecosystem, surfaces the best yield opportunities, and sends them to me on TG.
Sometimes it's worth revisiting what you've built. Good products keep working long after you've shipped them.