Onchain agents need altVMs

All onchain activity will soon be performed by AI agents. They'll need new rails.

Today, we're using crypto like we're driving Ford Model Ts in 1910.

I manually crank the engine (sign transactions), constantly check the oil pressure (monitor gas prices), and hope the brakes don't fail (pray my transactions doesn’t get exploited).

I manually claim my airdrops. My Aave position needs constant manual maintenance.

If I’m building something, I have to read the contract code to understand what I'm doing.

It's slow, it's painful, and—frankly—it’s holding us back from more mainstream adoption.

My normie friends won't touch crypto because it's too complex. Too unsafe.

Devs spend endless hours writing basic safety checks. Yet we keep losing millions to hacks and social engineering attacks because humans mess up—we miss details, we get tired, we click the wrong buttons.

AI agents are going to change this.

They're intelligent, autonomous programs that perform actions for us.

They can interact with any contract, watch market conditions all day long, and execute complex transactions automatically.

They don't get tired, they don't make simple mistakes, and they process way more information than we can.

With AI agents, we can finally use blockchain the way it should work—without all the complexity.

I tell my agent "keep my lending position healthy" or "find me the best yield" and it handles everything else.

No more watching charts all day. No more panic when markets move. No more struggling to understand new protocols.

I think we’re already seeing this shift happening.

I bet people are using agents to manage their portfolios, and MEV searchers have AI in their workflow and just aren’t sharing their alpha.

Soon, most blockchain interactions won't involve humans typing commands and signing transactions. Instead, AI agents will execute complex strategies at machine speed, handling everything from trading to lending to governance.

Agents want altVMs

Sadly—things will need to change for this future to be realised.

First, the EVM isn't built for an AI agent future.

It was designed when we thought humans would be writing all the code and making all the decisions.

But agents aren’t humans.

When my agent is running a DeFi strategy for me, it needs to check multiple pools at once, predict how trades will affect prices, find arbitrage opportunities, and execute everything at the perfect moment.

It’s juggling a ton of actions.

On the EVM, these operations have to wait in line, one after another. The EVM is like a one-lane road from the 1900s—it can only handle one carriage at a time.

AI agents need a modern highway system with multiple lanes.

That's why newer VMs like Move and Solana are better suited for AI agents. They were built from the ground up to handle parallel transactions.

We need safety guarantees for agents to work

There's another big problem with the EVM: safety.

When AI agents are handling millions of dollars of our money, we need to be absolutely certain they won't make mistakes.

With agents, we need compile-time guarantees that it won’t mess up, not just a promise that the code looks good.

Move gives us these safety guarantees built into the language itself— with "formal verification" (basically mathematical proof that the code will execute exactly as intended).

The EVM can't do this. Any safety checks on EVM are bolted on after the fact.

It’s like ordering an Uber vs jumping into a taxi. With Uber, we know upfront that we’re going to the right destination. With a taxi, you have to tell the driver after already getting in and assume that they know exactly where 420 N. 69th St.

Move also treats assets as special "resources" that can't be accidentally lost or duplicated. On the EVM, we’d have to write a ton of extra code to prevent these kinds of mistakes.

Move has guardrails built in, while EVM makes us build our own.

Let’s go back to the example where an agent is managing a complex DeFi strategy across multiple protocols.

In Move, the agent's funds and positions are protected by the language itself—only specific functions can touch them, and they can't be drained or duplicated by mistake. On EVM, we'd need to write all these safety checks ourselves, and one small oversight in our code could lose everyone's money.

Move also handles permissions in a way that makes more sense for AI.

Different parts of an agent might need different levels of access—like reading data versus making trades versus updating its own code. Move easily lets us set these permission.

EVM's basic permission system wasn't built for this level of granularity.

Going back to the car analogy (I love analogies): Move is an electric car built specifically for autonomous driving, while EVM is a regular car that we're trying to retrofit a bunch of self-driving apparatuses to it—by adding sensors and computers after the fact. Both can work, but one was designed for the job from the start.

The EVM served us well, but it's from the Model T era.

If we want more people driving more proverbial cars, we need VMs that were built with AI agents in mind from day one.

The future of crypto will be built on VMs that treat AI agents as first-class citizens, not as an afterthought.

Our computer overlords will love Move

Eventually agents will advance to developing artificial general intelligence and all of humanity will be pets for their entertainment.

When that happens, our robot overlords are going to take one look at the EVM and laugh. It's like showing them an abacus and asking them to run Netflix on it.

AGI won't mess around with systems built for human limitations.

As perfect machines, they'll want (and expect) 100% certainty and verifiability on every action. With formal verification, they’ll have mathematical guarantees that that their quadrillion-dollar trading strategies won't fail because some human dev forgot a null check (formal verification). With resources, they’ll know that their assets have rigid, unbreakable rules.

AGI will want everything built on pure math. No human shortcuts.

AGI will want iron-clad permission systems.

AGI will want parallel processing at massive scale.

Sure—our future AI masters may eventually build something that makes both Move and EVM look primitive.

But until then, Move's mathematical certainty makes it the clear choice for our future robot overlords over EVM.

Might as well start building on it now.