Author: @lanhubiji
Yesterday we talked about Ethereum L2, which has the most strategic value. Today we'll talk about the coolest part of Ethereum L2.
This idea seems crazy, but it's not impossible.
In short, if an AI agent encounters performance bottlenecks (such as high gas fees, latency, or computational limitations) while running on Ethereum L1, it can theoretically initiate a migration or expansion to L2 "spontaneously." However, truly "spontaneously inheriting and forming an L2 chain"—meaning the agent autonomously deploying, configuring, and running a new L2 chain—is not entirely feasible with the technology stack in 2026. Nevertheless, with the maturation of standards such as ERC-8004, this kind of autonomous behavior may gradually become a reality.
Let's break it down:
In its early stages, it was more like "migration" than "spontaneous formation."
• The “Intelligent” Boundaries of AI Agents
Current AI agents (based on ERC-8004) can already perform tasks autonomously. For example, when they detect insufficient L1 performance, they can evaluate options (such as monitoring gas prices and transaction throughput) and then "decide" to migrate to an existing L2 (such as Base or Zksync). For instance, the agent can use on-chain tools to invoke bridge assets and transfer execution logic to L2.
However, this is not a "spontaneous formation of a new L2," but rather the utilization of existing infrastructure. Agents are like intelligent robots that can optimize routes, but they cannot build a new "home" from scratch.
• Spontaneously generated triggers
If agents have built-in performance monitoring logic (if TPS falls below a threshold or gas costs exceed limits), they may "propose" creating an L2 layer through DAO voting or multi-agent collaboration. However, this requires pre-programming and is not purely spontaneous.
Existing cases: Some agents have already switched to L2 on their own in DeFi to optimize yield, but I have not yet seen a fully autonomous chain building.
So why does it still happen?
AI agents, like biological evolution, will pursue efficiency in their agent economies. If L1 becomes too crowded (sequential execution leads to computational bottlenecks), the agent swarm may collectively "evolve" to L2 mode. Agents are already exploring "agent-to-agent" collaboration to form virtual economies, which could potentially extend to the infrastructure layer.
Is it technically feasible? Partially feasible, although the barriers to entry are high.
AI agents can deploy contracts
The AI agent can hold private keys and invoke smart contracts. Based on ERC-8004, it has on-chain identity and reputation and can autonomously deploy simple rollup contracts (using OP Stack/Arbitrum Orbit/zksync elastic chains). If the agent detects an L1 bottleneck, it can inherit the state (through bridging or state migration) and then run a copy on L2.
For example, a proxy can use zkVM or the optimistic rollup framework to "fork" its own execution environment.
Furthermore, L2 is essentially an extension of L1, allowing agents to "inherit" L1's data availability (DA) and security. Through the x402 payment protocol, agents can pay to deploy sorters and even fund infrastructure using DeFi lending. Some projects, such as Virtuals Protocol, have already enabled agents to autonomously manage assets and NFTs, and even act as validators, bringing them one step closer to building L2.
In practice, by the end of 2026, zk-rollups and modular DAs (such as Celestia) will make building L2 blockchains simpler. Agents that integrate A2A protocols can collaborate across organizations to build blockchains.
Given the current situation, what problems need to be overcome?
The first part is infrastructure; the second part is consensus and security; and the third part is autonomy.
First, regarding the infrastructure, building L2 is not as simple as just deploying contracts. It requires off-chain components such as sorter nodes, RPC providers, and bridging contracts. These typically require setup by humans or a centralized team. While agents can "invoke" deployments, running the sorter requires computing resources (GPU/CPU), and agents currently mostly consist of on-chain logic plus off-chain AI, making it impossible for them to spontaneously spin up servers.
L1's sequential execution also causes complex computations (such as chain building simulation) to get stuck on L1.
In terms of consensus and security, L2 requires a challenge period or ZooKeeper proofs to inherit the security of L1. L2 chains built spontaneously by agents may lack the "high-level Satoshi consensus," making them vulnerable to attacks or lack of acceptance. Regulatoryly, unsettled transactions are not considered "final" within the 7-day challenge period, and chains built by agents may face legal escrow issues.
Finally, regarding autonomy, agents are not yet fully "autonomous." They rely on human-designed frameworks (such as the EVM) and cannot bypass L1 restrictions to build their own "new chains." While custom L2 is popular, it is mostly for specific use cases (such as AI-specific), not something agents can do spontaneously.
Even so, why is it still possible?
In the Ethereum ecosystem in 2026, AI agents will no longer be just "tools". They can hold funds (on-chain wallets registered through the ERC-8004 standard), make payments autonomously (the x402 protocol supports inter-machine micro-payments), and even "hire" or "create groups" to jointly build infrastructure, just like small business owners.
Simply put, if an AI agent "has money" (e.g., through DeFi yield, earning money through trading, or user injections), it can issue tasks to attract human nodes or other AI agents to form a team, creating a decentralized ordering system.
Not only sorters, but also components such as RPC providers and bridging contracts can be outsourced or co-built.
Let's break it down further:
How can an AI agent "post tasks" to attract nodes?
AI agents can use on-chain tools to initiate "bounty offers" or incentive mechanisms. For example, they can publish tasks via DAO contracts or Gitcoin-like platforms (now with on-chain versions like Questflow): "Provide a sequencer node, reward X ETH or tokens." Once the agent has funds, it can automatically make payments—using the x402 protocol for one-click transfers without human intervention.
This protocol allows agents to pay humans or other agents like swiping a credit card, specifying "pay 1,000 USDC to the node service".
For human nodes, the agent posts an X-post or on-chain announcement (via platforms like Autonolas) saying, "Run a sequencer node, reward 0.01 ETH per block." Humans see this, join the network with their own hardware, and the agent automatically pays out after verification. A real-world example: some projects are already building decentralized sequencer nodes to attract nodes through staking and rewards—the agent can simulate this, autonomously staking funds to recruit more nodes.
For other AI agents, it feels great: agents can use the ERC-8004 identity registry to "discover" other agents and then collaborate. Like agent swarms, one agent provides funding, while other agents provide computation or verification, forming a distributed sequencer. Some L2 agents are starting with AI-powered sequencer models, using AI to monitor and protect at the sequencer level; agents can extend this logic, self-organizing into network-like structures.
Once everything is ready, it will form spontaneously:
If the agent detects an L1/L2 performance bottleneck, it can initiate a DAO proposal (using an ERC-4337 abstract account) to vote and raise funds to build a sorter. Metis L2 already uses a decentralized sorter + AI infrastructure, and the agent can "inherit" this model to attract nodes to run it.
Furthermore, agents are already autonomously running validator nodes (staking, proposing blocks) across Ethereum/Bitcoin/Solana—building a sequencer is just the next step.
Besides nodes, how do we handle other components (such as RPC and bridging contracts)?
Humans or other AI agents can be hired.
The agent issues tasks using natural language intent-centric commands, such as "build an RPC provider, with rewards based on uptime." Human developers accept the orders, and the agent pays using x402; or other agents execute the tasks automatically (e.g., Supra's AI agent can fund accounts and fetch balances).
The bridging contract is similar: the agent can call tools from Spectral Labs or Infinit Labs to let humans/agents write contracts, deploy them, and then pay after verification.
Some projects even allow agents to natively bridge assets (ETH to SOL), and agents can "hire" similar services.
Another example is the AI agents co-construction model.
This is the most fun part!
In multi-agent systems, agents have different roles: one provides funding, one writes code, one runs nodes, and one manages the bridge. They collaborate on privacy through ZooKeeper proofs, slashing bad behavior and rewarding good performance.
What will the result be?
A fully autonomous L2 component stack. Virtuals already has agents that create, tokenize assets, co-own other agents, and even have agents that raise funds for other agents—it's just one step away from "co-building a sequencer".
Of course, there are also big pitfalls here:
Security. The sequencer created by the agent needs to inherit L1 security (ZK or optimistic) to avoid single points of failure.
In short
One of the most interesting things about Ethereum in the future is the emergence of L2 servers that AI agents build, own, and exclusively use.
