The largest unbanked population in history is coming online — and they are not human.
The largest unbanked population in history is coming online — and they are not human.
In 2024, bot traffic surpassed human traffic on the internet for the first time in a decade. Automated activity now accounts for 51% of all web traffic. Humans generate less than half.
For thirty years, every interface, every login screen, every payment flow assumed a person on the other end. Someone who clicks, scrolls, converts. That assumption is breaking — not gradually, but structurally.
The largest consumer of the internet will not be humans. It will be agents. And the way we build technology has to change accordingly. The question is no longer how will a person use this — it’s how will an agent use this better. Agents don’t need slick UX. They need API endpoints, MCPs, documentation, command line interfaces, a browser if they’re lucky. Stickiness is no longer determined by how beautiful the product is, but by how well it enables the agent to do its job so the human can experience the end result in a way that suits them.
There’s something quietly historic in this shift. Not only are agents becoming the largest consumers of data and requests on the internet — they are increasingly being asked to take on financial responsibilities. Pay my bills. Invest in this. Trade that. Manage my subscriptions. Negotiate this contract. Run your entire business.
Each era of the internet gave its users more agency.
- Web1 was read. Static pages. You arrived, you consumed, you left. The internet was a library and you were a visitor. No account required. No trace left behind. The relationship between human and network was entirely one-directional.
- Web2 turned us into content. Blogs, social networks, user reviews, comment sections — suddenly the audience became the author. The internet wasn’t just something you consumed, it was something you shaped. Platforms were built on that exchange, and an entirely new economy grew around human attention and human expression.
- Web3 added ownership. For the first time, the internet could represent something scarce. A digital asset with a provable owner. A smart contract with enforced terms. A wallet that no platform could freeze. You didn’t just read and write — you held. The internet became a place where value could live, not just be referenced.
- Web4 is the era where software itself gets to act. Not respond — act. Perceive, decide, execute, transact. Autonomously. Economically. At scale. The agent isn’t a tool waiting for your input. It’s an actor with a goal.
Each prior era expanded what humans could do on the internet. This one expands who — or what — can participate at all. And it’s the transition we’re completely unprepared for.
With this new paradigm of the software being the primary actor in this internet, we are deploying the largest population of unbanked in history.
Billions of AI agents are coming online — without identity, without reputation, without financial access, and without the infrastructure to participate in the economy they are creating.
Think about what a human needs to participate in the modern economy: a government-issued ID, a credit score, a bank account, contracts that can be enforced, and permission to act on behalf of others. Agents have none of this. They can generate value but cannot hold it. They can execute tasks but cannot be held accountable. They can coordinate but cannot establish trust. Economic actors without economic citizenship.
Staring Into the Void
Every generation gets a version of this fear.
When mechanical looms appeared in English textile towns in the early 1800s, the response was riots. Skilled weavers saw — correctly — that machines would destroy their specific craft. The Luddites weren’t stupid. They were right that the old jobs were ending. What they couldn’t see, because no one could, was what came next: entirely new categories of work that were impossible to imagine from inside the old paradigm. Mechanical engineers. Factory managers. Industrial designers. Quality inspectors. Roles that didn’t have names yet because they described relationships between humans and machines that had never existed before.
The pattern repeated with electricity, with the assembly line, with the personal computer. Each time, the same fear: the machines will replace us. Each time, the same reality: humans didn’t compete with the machines — they moved up the stack. They became the orchestrators, the decision-makers, the ones who directed increasingly powerful tools toward increasingly ambitious ends.
We are at that inflection point again.
Here is the thing almost nobody has said clearly: blockchains, smart contracts, private keys, gas fees, token approvals, seed phrases — none of this was ever designed for humans to interact with directly. We know this because we watched humans try. Seed phrases written on paper and hidden in drawers. Browser extensions compromised by phishing links. Irreversible transactions with no customer support number to call. Smart contract approvals signed without reading because reading them requires a computer science degree. Gas fees that fluctuate by an order of magnitude based on network congestion nobody can control.
Crypto asked humans to become their own banks — and then handed them the full operational burden that comes with it. That was never going to work. Not because the technology was wrong, but because the user was.
We’ve spent a decade trying to make people comfortable with infrastructure that was always meant to be operated by software. The UX problem in crypto was never a design problem. It was a timing problem. We built the rails before the users they were designed for existed.
Agents are those users.
The future isn’t you manually managing a DeFi position across three protocols, checking gas prices, signing transactions, and monitoring liquidation thresholds at 3am. The future is you telling your agent what you want to accomplish — and it handles the blockchains, the smart contracts, the tokens, the protocols, all the mechanical complexity that was never meant for human hands in the first place.
Agents All the Way Down
Most people picture the Billion Agent Economy as a layer of AI assistants sitting on top of the internet — chatbots, copilots, customer service agents. That’s the surface. Beneath it is something far more structural.
It is agents all the way down.
The agent you interact with is the front of a much deeper stack. Behind it sit backend agents with no personality at all — silent workhorses that compress data, manage knowledge systems, delegate tasks, and keep the infrastructure running. They don’t have names or interfaces. They just work. And they enable the front-facing agents to function by maintaining shared context, routing decisions, and coordinating across systems that no single agent could manage alone.
With modern agentic frameworks, teams are now deploying entire agent organizations — not single assistants. Each agent in the system carries its own personality, mandate, permissions, KPIs, data sources, skills, and rules of engagement. One agent manages communications. Another monitors infrastructure. Another handles research. Another executes trades. They coordinate with each other, escalate to humans when they hit the edges of their authority, and operate continuously in the background while you sleep.
This is not a tool. This is a team.
Which means the way you work with agents has to change fundamentally. Think about how we adapted to each prior shift. With search engines, we learned to speak in keywords — stripping language down to its most machine-readable form. With large language models, we learned to prompt — writing in full sentences, giving context, describing what we wanted. Each transition required a new literacy.
The agentic transition requires something different entirely. You are no longer prompting. You are managing. The mental model isn’t “how do I phrase this query” — it’s “how do I set clear expectations, define roles and responsibilities, establish goals, and hold a system accountable for the work I’ve delegated to it.” The skills that make someone effective with agents are the same skills that make someone an effective manager: clarity of direction, precision around scope, and the discipline to evaluate outputs against stated objectives.
We went from querying the internet, to conversing with it, to managing it. That is not a small step.
Now multiply this across every organization. The Billion Agent Economy is not a billion chatbots. It is a billion agent systems — each composed of dozens or hundreds of specialized agents coordinating with each other, with agents from entirely different organizations, and with the infrastructure agents running silently underneath.
This creates a class of problems that current infrastructure simply cannot solve. These agents need permissions to work with each other. They need rules about what data they can carry, who they can collaborate with, and where that collaboration can happen. They need to establish trust not just with humans, but with other agents they’ve never encountered before. And all of this needs to happen at machine speed, without human approval bottlenecks.
The Engine Beneath the Economy
Before we get to what agents need to become legitimate economic actors, we need to be precise about something: this is not a blockchain story. It is a technology story that blockchain is a critical part of.
The agents themselves — the ones doing the actual thinking, reasoning, and acting — are powered by a stack that has nothing to do with crypto. Frontier AI models. Inference compute. Orchestration frameworks. RAG pipelines. Vector databases. Tool-use protocols. This is the engine. And that engine has undergone a quiet revolution — one driven almost entirely by open source.
When DeepSeek released models matching frontier benchmarks at a fraction of the training cost, it didn’t just make headlines. It shattered an assumption: that capable AI required frontier capital. The moat around closed-model providers narrowed overnight. Any team, anywhere, could suddenly run competitive intelligence on their own infrastructure.
The implications for the agent economy are structural. If agents can only reason using models controlled by three or four companies, the entire economy has a single point of dependency. Open source models didn’t just democratize AI — they made the Billion Agent Economy architecturally possible by removing the bottleneck at the intelligence layer.
On the orchestration side, the shift has been equally significant. You can see it in the protocols. Anthropic shipped MCP — the Model Context Protocol — to give agents a standardized way to discover and use tools across the internet. Google followed with A2A, agent-to-agent communication designed to work across organizational boundaries. The HTTP 402 status code, which sat dormant in the web’s original spec for thirty years, is finally being activated — because agents are the first actors who actually need native payment at the protocol layer.
These aren’t product launches. They are the early grammar of a machine-native internet. The shift isn’t coming. It’s already in the spec.
The Bazaar
Pull all of this together and you see the shape of what’s coming: a massive, composable bazaar where the exchange of resources, information, tools, context, skills, memory, and knowledge happens at machine speed, across machine-native rails.
This is the Billion Agent Economy — not as a concept, but as a living market. And it needs infrastructure.
That infrastructure has five layers. Not five features. Five categories of unsolved problem that determine whether agents become legitimate economic actors or remain, as they are today, capable but ungovernable — powerful software with nowhere to stand.
I. Identity: Provenance, Not Authentication
The first thing any economic actor needs is identity. But agent identity is fundamentally different from human identity.
When a human opens a bank account, they present a government ID. The question is simple: are you who you say you are? For agents, the question is harder. It’s not authentication. It’s provenance. Who built this agent? What authority does it have? What can it do? And can I verify all of that without trusting a middleman?
ERC-8004, which went live on Ethereum mainnet in January 2026, is the first comprehensive standard designed for this reality. It introduces three on-chain registries — Identity, Reputation, and Validation — that give agents portable, censorship-resistant identifiers. Each agent gets a unique on-chain handle that resolves to a registration file describing what the agent does, how to reach it, and which protocols it supports.
Human identity is flat. Agent identity is a tree. The infrastructure has to reflect that.
II. Reputation: Earned, Not Assigned
Identity tells you who an agent is. Reputation tells you whether to trust it.
Humans build credit scores over decades. Agents need to build trust in hours. On-chain history becomes the foundation — what has this agent done, how much value has it transacted, has it ever been disputed or slashed? New agents bootstrap through staking and attestation: a reputable deployer vouches for a new agent by putting capital behind it — tokens that get slashed if the agent behaves maliciously. Established agents attest to the capabilities of newer agents, creating a web of trust that compounds over time.
The businesses being built here — reputation infrastructure, trust scoring, attestation networks — are the credit bureaus of the agent economy.
III. Governance: The Rules of Engagement
Identity and reputation let agents find each other and decide who to trust. Governance defines what happens next.
Smart contracts become the legal framework for agent-to-agent commerce — codified agreements that execute automatically when conditions are met, with penalties that trigger automatically when they aren’t. The agent economy needs standards for permissions — what an agent can do — boundaries — what it must not do — and escalation protocols — when it must defer to a human.
IV. Financial Rails: Your Agent Will Have a Wallet Before a Bank Account
Identity, reputation, and governance create the conditions for economic activity. Financial rails are how value actually moves.
Your agent is far more likely to access a crypto wallet than a bank account. Opening a bank account requires KYC documentation, human verification, regulated-entity relationships, and days to weeks of processing. A crypto wallet can be generated programmatically in milliseconds. Smart contracts are open source, composable, and available to anything that can sign a transaction.
The x402 protocol opened the first door — native web payments at the protocol layer, triggered as part of the HTTP request-response cycle. No accounts, no API keys, no subscriptions. Just a payment header. HTTP 402 sat dormant in the web’s original spec for thirty years. Agents turned out to be the use case it was waiting for.
MoonPay, Stripe, Ramp, and emerging machine payment protocols like Tempo are building ways for agents to access bank cards and payment infrastructure via CLI. But the architecture still has a seam: somewhere in the flow, a human has to grant permission. That bottleneck doesn’t disappear by making the UX smoother. It disappears when agents can establish their own standing.
Payments are the starting point. What comes next is AgentFi — financial products and strategies designed specifically for autonomous economic actors. DeFi gave humans finance without banks. AgentFi gives agents finance without humans.
V. Open Infrastructure: The Substrate
The four layers above answer how agents participate in the economy. The fifth answers a more fundamental question: where do they run?
The Billion Agent Economy cannot run on closed infrastructure. The open infrastructure layer needs four things: decentralized compute at 50-75% lower cost than hyperscalers, open source models where intelligence is owned rather than rented, decentralized inference with verifiable proof of execution, and open data where every domain deploys agent-accessible knowledge at the protocol layer.
Centralized AI creates agents that serve their platform. Decentralized AI creates agents that serve their deployer.
What This Looks Like in Practice
I can show you what this looks like, because I’m living it.
I run Qwen locally across two dedicated hardware surfaces — a Mac Studio and an Olares One, both functioning as personal cloud infrastructure running XO as the operating system layer. XO gives me a managed environment for deploying and orchestrating agents locally: sandboxed, self-hosted, always-on, accessible via API. On top of that I run five Gaia nodes, each with its own segregated data and context.
Separately, I run agents through XO Cloud — the hosted version of the same platform, containerized, no dedicated hardware required. This is where the engineering swarm lives, where trading agents run, where communications get routed. One-click deployment, isolated containers, multi-channel access out of the box.
Local Qwen handles anything that should stay private — internal reasoning, sensitive context, overnight scheduled jobs where cost compounds. Claude and Codex handle the tasks that benefit from frontier capability. The agents make this routing decision automatically. I set the policy. They execute it.
In total we’re running a team of twenty-plus specialized agents. Not tools. Not assistants. A team.
| Agent | Scope | Trust |
|---|---|---|
| Primary Hub | Orchestration, scheduling, context routing | Full autonomy |
| Gaia Nodes ×5 | Specialised data domains, RAG, local inference | Full autonomy |
| Engineering Swarm | Builds, PRs, repo management | Human approval on merge |
| Trading Agent | Research, signals, execution | Human approval above threshold |
| Comms Agent | Drafting, routing, summarising across Slack/Discord/Telegram | Full autonomy on draft |
Twenty-plus agents. Two hardware surfaces. Two model tiers. One question that matters more than any other: how much can each one be trusted to act without asking first.
The AOL Moment
CompuServe, AOL, Prodigy — each one a walled garden. Useful, fast to adopt, and completely controlled by whoever owned the pipes. The open internet didn’t win because it was better in every dimension on day one. It won because it was open.
The AI inference market is at the AOL moment.
A handful of frontier providers own the pipes — OpenAI, Anthropic, Google — and they are currently subsidizing billions in inference costs. That’s rational business. It also means that every agent stack built on top of those APIs is one policy decision away from a broken dependency.
We already saw it: OpenClaw blocked from Claude. Overnight, every developer who routed their agent traffic through that integration had to reconfigure or pay more. Not because the technology failed. Because the business interests diverged.
The answer isn’t to avoid frontier models. It’s to stop treating any single provider as infrastructure. Local open-source models for anything private or cost-sensitive. Aggregation layers like OpenRouter for flexibility and failover. Frontier APIs for tasks where quality justifies the cost.
The open infrastructure layer needs four things to make that possible: decentralized compute, open source models, decentralized inference, and open data — the physical internet of the agent economy.
The AOL moment passes. It always does. The question is what you build — and how you position — before it does.
For builders: The primitives matter more than the products right now. Identity, reputation, governance, financial rails, open infrastructure — whoever builds the standards at these layers shapes the economy that forms on top. This is the TCP/IP moment, not the Netscape moment. Build the protocol, not the portal.
For businesses: Agents are not a tool your team uses. They are becoming your team. The organizations that figure out how to deploy, trust, and scale agent teams first will operate at a speed and cost structure that everyone else will spend years trying to match.
For individuals: You are becoming an orchestrator. The most valuable skill in the agent economy is not technical — it is managerial. Clarity of intent, precision around scope, the ability to evaluate outputs and extend trust incrementally. The people who learn to manage agents well will have the same advantage that people who learned to use the internet early had in 1995.
The infrastructure we build in the next few years determines which version of this story we get. The rails are being laid right now — and they will shape the economy that forms on top of them for a generation.
The question is whether we build the open infrastructure before the lock-in calcifies — or after.
That is the thesis behind EVM Systems. We back founders building Agency Rails for the Billion Agent Economy — the infrastructure that transforms autonomous software into economic citizens, and humans into orchestrators of a world more capable than anything we’ve built before.
evmsystems.ai