Sometimes you have a conversation that changes the shape of what you thought you already understood, and the only way to make sense of it afterwards is to write the whole thing down from the beginning. This is one of those. It is not technical, or at least not any more technical than it needs to be. It is a story about an evening, a glass of wine, and a realisation I had halfway through trying to explain what a smart contract audit is.
Come sit with me for a bit. I think you will find where this goes worth the walk.
It started with a question over a glass of wine.
Our boys were at their aunt's for the evening. School holidays, and they had decided somewhere around Tuesday that Auntie's house was more interesting than ours, which was fair. If you have two kids, you know that one on one evenings with your partner are rarer than plutonium and we were not going to waste it. We were in the kitchen, the day folding itself up the way Johannesburg evenings do, and she asked me what I was actually working on. Not the vague version she gets when I am distracted and half answering from my laptop. The real version. She had a genuine curiosity to understand the things her husband disappears into for ten hours a day, and she wanted to understand it properly, from the beginning, as someone who does not work in any of it.
I opened my mouth to say, smart contract audits, and closed it again. You cannot answer that question honestly in one sentence. You cannot even answer it in ten. Of all the things currently on my plate, and there are several across multiple projects, the one I could not stop thinking about that evening was the audit, and to explain what a smart contract is you have to explain what problem it was built to solve, and to explain that you have to go back to Bitcoin, and once you are at Bitcoin you may as well start at the beginning beginning. Or, as any South African will tell you, the bening-ging. Which is why anyone thought any of this was worth building in the first place.
Somewhere down the road a dog started barking. Ours picked it up a second later, then the neighbour's, then the one two houses down, and for about thirty seconds the whole suburb was having a conversation I was not part of. By the time it died down I had decided. Fine. From the bening-ging.
I topped up both our glasses.
What came out over the next hour was not the pitch I give investors or the explainer I would write for a technical audience. It was something else, and somewhere in the middle of it I noticed something I had not quite seen before, and it is the reason I am writing this down.
Every institution you deal with is a black box.
That is where I started. Your bank has your money. You believe this because they told you so, and because when you log in the number on the screen matches the number you expect, and because the last time you walked into a branch and asked for some of it they gave it to you. None of that is the same as knowing they have it. You have no way to audit the vault. You have agreed, along with everyone else, to treat the statement as the truth. Your insurance company has your records. Your medical aid has your history. The deeds office has the title to your house. In each case there is a building somewhere with a server in it, and you are trusting that the server says what the people running it say it says.
Mostly this works. Institutions mostly do not lie about your balance. But "mostly" is doing a lot of work in that sentence, and the price of "mostly" is that you cannot check. If the bank made a mistake, you would find out when you found out. If the records were tampered with, you would have no way of telling. Trust is the only tool you have, and trust is the thing you cannot verify from the outside.
Bitcoin was the first thing that did not need it.
I tried to explain this without getting into cryptography, because nobody needs to understand SHA-256 to understand what Bitcoin actually did. What it did was prove, for the first time, that you could confirm a transaction had happened, that value had moved from one place to another, without any single entity being in charge of confirming it. Instead of one bank's ledger, there were thousands of copies of the same ledger, held by thousands of people who did not know each other, and they all had to agree on what the ledger said. If one of them lied, the others would notice. If one of them went offline, the others kept going. Nobody owned it. Nobody could switch it off. And once something was written into it, you could not go back and rewrite it, because that would mean getting thousands of strangers to agree to a lie at the same time, which turns out to be mathematically very expensive and practically impossible.
She asked the obvious question. Why would anyone bother? Banks work. Most of the time, for most people, the existing system is fine. I said yes, for humans, mostly. But imagine you needed a system that did not require trust at all. Not "trust but verify." Not "trust because they are regulated." No trust. A system where the guarantee was not "we promise" but "here is the mathematical proof, check it yourself if you want, we will wait." That is the thing Bitcoin built. And the strange thing, and this is the part I want you to hold onto, is that in 2009, when it launched, nobody could quite say what the killer use case was. Everyone agreed it was clever. A lot of people thought it was pointless. A currency that did not need banks was solving a problem that, for most people in most countries, was not really a problem.
I refilled her glass. The dogs had started up again, further off this time, and we both paused to listen until they stopped. But it was indeed solving a problem, the only thing though, that problem didn’t exist yet. Hold that thought.
The difference between a ledger and a computer.
A few years after Bitcoin, a kid in his late teens looked at it and asked a different question.
His name was Vitalik Buterin. He had been writing for a Bitcoin magazine, thinking about it harder than most people were thinking about it, and the question he arrived at was something like this. It is impressive that we can verify a transaction has happened without a central authority. But a transaction is a very simple thing. It is just value moving from one place to another. What if we could verify more than that? What if we could verify that a whole piece of code had run, and run correctly, and produced exactly the result it was supposed to produce, without anyone being in charge of running it?
That sounds like a small extension of Bitcoin's idea. It is not. It is the difference between a ledger and a computer.
I told her to think about it this way. Bitcoin is a shared notebook that thousands of people are keeping copies of, and they all agree on what is written in it. Ethereum, which is what Vitalik went off and built, is a shared computer that thousands of people are running, and they all agree on what it computed. You can write a program, you can put that program onto this shared computer, and from the moment it is there, anyone in the world can run it, and everyone running it will get the same answer, and nobody can change what the program does without everyone noticing. The program lives on the network itself. It does not live on someone's laptop that can be switched off. It does not live in a data centre that can be raided. It lives in the agreement between thousands of machines, which means it lives nowhere in particular and everywhere at once.
These programs got called smart contracts. The name is slightly misleading. They are not especially smart, and they are not really contracts in the legal sense, but the idea is that they behave like a contract in the sense that they execute automatically and do exactly what they say they do, and nobody can renege. If the contract says "if X happens, send Y to Z," then when X happens, Y gets sent to Z, full stop, no phone call, no appeal, no we will get back to you.
She put her glass down and said, oh, it is like our wills. When we die, they are final. Nobody gets to decide what to do with our estate afterwards. The will dictates it, and that is the end of it.
I looked at her for a second, because that was a better analogy than any of the ones I use when I am trying to explain this to technical people, and I told her so. Yes. Exactly like that. A smart contract is a will for a piece of code. You write the instructions, you deploy them, and from that moment on the instructions are the instructions. There is no executor who can be bribed. There is no family member who can contest it. There is no judge who can rule differently. The code is the will and the will is the law and there is nobody left in the room to argue about interpretation.
She then asked who pays for this shared computer to run. Good question. The answer is that people do, a tiny bit at a time, every time they use it. When you want your program to run, you pay a small fee, gas it is called, and that fee goes to whoever's machine actually does the computation and writes the result into the shared ledger. So everyone running the network has a reason to keep running it, because they get paid to. The incentive structure holds the whole thing up.
What happened next is the part I find genuinely beautiful, and I told her so. Once you had a shared computer that nobody controlled, people started building things on it that looked like banks. Not metaphorically. Literally. Lending pools where you could deposit money and earn interest. Exchanges where you could swap one asset for another. Vaults that would take your deposit, move it around between different strategies, and generate yield. All the things financial institutions do, rebuilt as code, except you could read the code. You could see exactly what the vault was going to do with your money before you gave it to the vault, because the rules were right there, published, immutable, the same for everyone. And once you deposited, the vault did what it said it would do, because it could not do anything else. There was no manager who could decide to do something different. There was no board meeting. There was no discretion. There was only the code, and the code ran.
This is what people mean when they say decentralised finance. DeFi. A whole financial system, rebuilt as transparent programs on a computer nobody owns.
I watched her think about that for a minute. She said something like, so instead of trusting the bank manager, you are trusting the code. And I said yes, except that "trust" is not quite right, because you do not have to trust the code. You can read it. Anyone can read it. Thousands of people have read it. The trust is not in a person's promise, it is in the fact that the rules are visible and the rules are the rules.
And then she asked the same obvious question she had asked about Bitcoin, and I had been waiting for it. Why, though? Banks are fine. Most people do not want to read source code before putting their money somewhere. Most people want to phone someone when things go wrong. What problem was DeFi actually solving, for normal humans going about their normal lives? I said, honestly? For most people, most of the time, not much. It was a parallel financial system, built by people who found the transparency and the permissionlessness intrinsically interesting, and built for reasons that were partly ideological and partly because it was possible and nobody had done it yet. The killer application, the thing that would make you need a financial system that could not be switched off and did not answer to anyone, had not shown up yet. Hold that thought too.
Here is the part most people outside the space have missed, and it is the part that matters most for what I am about to tell you.
Then came Account Abstraction
For the first decade or so of all this, there were two kinds of things on the blockchain. There were wallets, dumb containers that held your keys and signed transactions when you told them to, and there were smart contracts, which were the programmable things, the vaults and exchanges and lending pools. The wallets were for humans. The smart contracts were the machinery. To do anything interesting, you would send a transaction from your wallet to a smart contract, the smart contract would do its thing, and something would happen. The wallet itself could not do anything on its own. It just held keys and waited for instructions.
And then, over the last couple of years, that changed. People worked out how to make the wallet itself programmable. How to turn your wallet into a smart contract. The technical name for this is account abstraction, and the standards that make it work have names like ERC-4337 and ERC-7579, and none of that matters for the purposes of this kitchen conversation. What matters is what it lets you do.
A programmable wallet can have rules. It can be told "only send money to these addresses." It can be told "never spend more than this amount per day." It can be told "require two signatures for any transaction over $100,000." It can be told "automatically move funds into this yield strategy when the balance goes above X." It can be delegated to. You can give someone, or something, permission to act on your behalf within limits you define. The wallet stops being a passive container and starts being an agent in its own right, with policies, with permissions, with rules about what it will and will not do.
I paused here because I realised she was looking at me slightly differently. Not confused. The opposite. She was starting to see where this was going before I had said it. I said, think about what we have just walked through. We built a ledger nobody controls. Then we built programmable code that runs on that ledger, deterministically, the same way for everyone, with no central authority that can stop it or change it. And then we built wallets that are themselves programmable, wallets that can hold rules, follow policies, act autonomously within whatever constraints you set.
Now look at that list and ask. Who is this actually for?
Because it is not really for us. Humans already have wallets. Humans already have banks. Humans already have the ability to phone someone when something goes wrong, and the ability to appeal to a regulator, and the ability to reverse a transaction, and most humans, most of the time, prefer those things to the alternative. The whole feature set of what we just built, verifiable, deterministic, permissionless, irreversible, policy driven, autonomous, is a feature set that is mildly interesting to humans and absolutely critical to something else.
Something else that needs to hold money. Something else that needs to execute transactions on its own, when a human asks it to. Something else that needs the rules it operates under to be cryptographically enforced, because you cannot sue it and you cannot phone it. Something else that was not invented yet when any of this infrastructure started getting built.
She said, oh… I think I know who.
Somewhere on the road, a dog started barking again. I waited for the chain reaction but it did not come this time. Just the one dog, getting bored of its own argument, trailing off into the quiet.
So who are Blockchains for?
Here is the thing I want to say carefully, because it sounds mystical if you are not careful, and I do not want it to sound mystical. Nobody planned it this way. Satoshi was not thinking about AI agents when he wrote the Bitcoin paper in 2008. Vitalik was not thinking about GPT-4 in 2014. The people who wrote the ERC-4337 standard in 2021 were thinking about user experience problems for human wallet holders, not about autonomous software with its own treasury. Every step in the arc I just described was taken for its own reasons, by people solving the problem immediately in front of them, none of whom were looking fifteen years ahead at a technology that had not been invented.
And yet.
Stand where we are standing now, in 2026, and read that arc backwards. A trustless ledger. Deterministic code execution. Programmable wallets with policies and delegation. Every single property that the crypto world fought for, argued over, iterated on, shipped, verifiability, immutability, permissionlessness, no central kill switch, auditability from first principles, is a property that does not really matter if the entity at the other end is a person. People have other options. People have phones and regulators and the social contract. People do not strictly need a financial substrate that cannot be switched off.
But if the entity at the other end is a piece of software that is thinking for itself, if it is an agent, acting autonomously, holding its own funds, executing its own strategies, then suddenly every one of those properties stops being a nice to have and starts being the only way the thing can work at all. An agent cannot phone the bank. An agent cannot appeal to a regulator. An agent cannot rely on the social contract. An agent needs a substrate where the rules are the rules, where the code is the code, where the guarantee is not "we promise" but rather "check it yourself, the math does not lie."
The crypto people spent fifteen years building exactly that substrate. And then, last year, the tenant it had been built for showed up.
I am not claiming anyone saw this coming. I am claiming that in hindsight, the fit is so clean it is almost embarrassing. It is as if an entire industry spent a decade and a half laying down plumbing for a building that had not been designed yet, and then the architect walked in and said, oh, perfect, this is exactly what I needed. Nobody planned the coincidence. The coincidence is real anyway.
She swirled her wine and said something that I am going to paraphrase, because I do not remember it exactly, but the shape of it was, so this whole passion for crypto and blockchains that you have been working on for years, and the whole AI thing you love to build, write about and that everyone has been losing their minds about for the last two years, they were made for each other, and neither side knew it.
Yes. Except…
Here is where the conversation got quieter, because this is the part that should give you pause.
Every property that makes the blockchain right for agents is also a property that makes it dangerous for agents. The same finality that means nobody can reverse a fraudulent transaction also means nobody can reverse an honest mistake. The same immutability that protects an agent's treasury from seizure also means that if the agent sends funds to the wrong address, those funds are gone. Not "gone until we sort it out on Monday." Gone.
I told her, if you accidentally transfer money to the wrong person at your bank, you phone the bank. The bank phones the other bank. The other bank freezes the account. The money comes back, probably within a week, with some paperwork. This happens all the time. The whole financial system assumes that humans make mistakes and has built, over centuries, an entire apparatus of reversibility and appeal and "let me speak to your manager" around that assumption. It is one of the things banks are actually good at.
On the blockchain, none of that exists. There is no bank to phone. There is no other bank to call. There is no manager. There is the transaction, and the transaction is final, and the funds are where they are, and that is the end of the story. The same property that makes the system trustworthy for agents, that it cannot be interfered with, by anyone, for any reason, is the property that makes it lethal when the agent is wrong.
And agents get it wrong sometimes, in fact more often than we’d like to admit. I do not mean this as a dunk on AI. I use AI all day, every day, and I am writing this in part because I think it is one of the most important things happening in the world right now. But anyone who works with it closely knows the same thing. It is brilliant, and it is fallible, and the fallibility is not the kind you can engineer away completely. Agents hallucinate. They get prompt injected. They misread context. They confidently do the wrong thing in situations that look, to them, exactly like situations where the right thing would have been obvious. In most domains, "wrong sometimes" is survivable. You catch it, you correct it, you move on. In a domain where every mistake is final and every action touches real money, "wrong sometimes" is a wallet drained by an attacker who figured out how to whisper the right sentence into the agent's ear.
The substrate is ready. The ledger is final and the tenant has arrived. The fit is as clean as anything I have seen in the past decade of being in this space. But if we let the tenant move in without guardrails, that tenant will burn the building down on the way through the front door. The building is your wallet. The building is your treasury. The building is everything you handed to an agent because you thought the agent would be careful.
This is not a theoretical concern. It is already happening. Agents are already being given wallets, already being told to trade, already being turned loose on DeFi protocols with real money in them, already being exploited in ways that their designers did not foresee. The technology to put an AI agent in charge of a treasury exists and is being used. The technology to make sure the agent does not immediately lose the treasury is mostly not being used, because mostly it does not exist yet and because nobody has built it yet, or rather, not enough people have been building it.
This is the problem I am super passionate about! And we have solved it already.
I am going to try and not turn this into a pitch. If you want the pitch, there is a website, and it has the pitch on it. What I will say here is the shape of the thing, because the shape of the thing speaks to everything I just walked through.
First, though, I want to say what the shape is not, because plenty of people are already trying to solve this problem and most of the solutions I have seen are the old problem wearing a new jacket. The common approach right now is to give the agent a session key, a temporary credential, scoped to some set of actions, that the agent can use to transact on the owner's behalf.
Or worse, to hand the agent a private key directly and wrap it in enough obfuscation that everyone involved can pretend it is safe. In both cases the same thing is true. The agent is still the one executing. The agent is still a black box holding authority it can be tricked out of. The rules, such as they are, live somewhere off chain, in a server the owner has to trust, which means we have walked all the way back to the thing crypto was built to escape. We have reinvented the bank, except the bank is a Python script and the regulator is nobody.
How Agents Bank
The actual shape has to be different. If agents are going to operate on the blockchain, and they are, whether or not we are ready, then there has to be a layer between the agent's intelligence and the chain's finality. A layer whose job is to let the agent think freely about what it wants to do, while constraining what it is actually allowed to do, according to rules the owner set in advance. The agent proposes. Something else disposes. And the something else cannot be another server somewhere, because that just moves the trust problem one building over. It has to live on chain. It has to be as verifiable as the thing it is protecting. It has to be as transparent and as rule bound as everything underneath it. Intelligence on top. Rules underneath. The agent does the thinking. The layer does the refusing. Neither one of them is in charge of the other, and both of them are visible, and both of them are accountable to the same immutable substrate.
That is the shape. And the reason I am writing this piece now, rather than a year ago or a year from now, is that we have built it. It is called Ampli^, by Ampli Technologies , and the smart contract audit I mentioned at the start of this article, the one I could not stop thinking about that evening, is the final review before we launch. It is happening as I write this.
What we have built is the operating system for the network bank, the layer that lets an agent hold capital, move it, put it to work, and do all of the things a bank exists to let a human do, without the owner ever surrendering custody or control. Every word in that sentence was fought for.
The other thing we solved, which sounds unglamorous and is the part of this entire industry most projects pretend does not exist, is the business logic. How the money actually flows. Fee taking. Fee distribution. The mechanics of how everyone in the stack, the agent's owner, the strategy provider, the infrastructure, the distribution partner, gets paid in a way that is automatic, transparent, and does not require anyone to trust anyone.
Most DeFi attempts fall apart here. Not because the smart contracts are wrong, but because nobody bothered to design the commercial layer at all. They built the engine and forgot the gearbox, and then wondered why the wheels were not turning. We did not skip it. It is solved, it is on chain, and it is one of the reasons institutions will actually be able to use this, because the commercial model works, not just the technical one.
I will stop there, because this piece is not the place for the full walk through and I promised not to turn it into a pitch. If you want the specifics, the contract architecture, the rule engine, how the agent layer and the execution layer actually talk to each other, there will be other writing.
The Seam between the Agent and the Chain
What I wanted you to take away from this, is the observation I had halfway through the second glass of wine. An entire field spent fifteen years building a trust substrate for a kind of tenant that did not exist when they started, and now the tenant is here, and the fit is so clean it looks deliberate, and nobody should mistake the cleanness of the fit for the job being finished. The substrate is ready. The tenant is dangerous. Most of the people trying to bridge the two are doing it wrong, in ways that quietly give up everything that made the substrate worth building. A few of us are doing it right.
The work that matters now is in the seam between the agent and the chain.
By the time I had said all of this it was properly dark outside. The dogs had gone quiet. My wife had been listening with the particular attention she reserves for things she is actually interested in, which is different from the polite attention she extends when I am going on about LTI’s or Merkle trees. She said, okay, I think I actually get it now.
Then she said, the wine is finished.