AI agents can now handle tasks that would have taken humans hours, from scanning markets to drafting code. But when they start spending money, moving assets, or coordinating with other software across companies, raw smarts fall short - they need a foundation of identity, verifiable actions, and settlement that cannot be faked or revoked. Web3 steps in here with public registries, cryptographic proofs, and economic incentives, covering some layers better than others.
Key Takeaways
- Moving Beyond Chat: We’re moving from AI that only answers questions to digital actors that can actually act on their own.
- Proof of Identity: New standards are emerging to ensure that we can verify digital agents and their responsibility.
- Direct Payments: We’ve got systems now that enable agents to pay for services instantly without a human approving.
- Flexible Resources: Instead of locked-in contracts with giant data centers, programs can now rent specific bits of computing power only when they are actually using them.
- Dependable Storage: New ways of storing information allow for cost savings while ensuring secure data exchange across different platforms.
- Automated Rights: The licensing and ownership rules baked right into the code, so creators get paid automatically every time their data is used.
- Mathematical Certainty: Moving away from blind trust in AI agents toward using math to prove that their work has not been tampered with.
The Next Thing:
The immediate challenge is to get all these separate tools to work together so that digital systems can run end to end without technical friction.
Why Agents Can't Just Trust Each Other
When two humans transact, they rely on interconnected systems of accountability: legal identity, reputational history, and the possibility of recourse. Neither party starts from zero.
AI agents have none of that by default. An agent operating autonomously has no social standing, no passport, no credit history, and nobody that can be held liable. If it sends a payment, there's no guarantee the recipient is who they claim to be. If it receives an output from another agent, a price feed, a completed task, a signed document, there's no default mechanism to verify the output wasn't manipulated or generated by a compromised model.
The deeper issue is coordination. Agents interacting across platforms, networks, and jurisdictions need a shared language for trust. Without it, every deployment either builds its own proprietary trust system that doesn't scale or defaults to centralized intermediaries, which defeats much of the purpose. This is already a live constraint. Multi-agent systems are running in production today across DeFi, data markets, and automated workflows. The projects that have gotten furthest are the ones that built their own identity and reputation layers from scratch, because no shared standard existed when they started.
The web solved the equivalent problem for humans over decades, through DNS, TLS certificates, payment rails, and legal frameworks. Agents need the same kind of layered infrastructure. The difference is they need it in years, not decades.
The Infrastructure Stack, Layer by Layer
Understanding where Web3 fits requires understanding the full stack agents depend on. It's not just payments. The layers are distinct, and Web3's contribution varies significantly across them.
AI Identity and Reputation
AI agent identity is a new and actively developing layer of infrastructure. Different ecosystems are approaching it from different angles, and that's expected at this stage.
On Ethereum, ERC-8004 is the most formally specified approach. Live on mainnet since February 2026, it defines three on-chain registries covering identity, reputation, and validation hooks for agent work. The standard was co-authored by contributors from the Ethereum Foundation, MetaMask, Google, and Coinbase. Ethereum Name Service (ENS) adds ENSIP-25 (AI Agent Registry ENS Name Verification) - a human-readable verification layer on top. The ENS name owner sets a standardized text record linking their name to a registry entry, and wallets or dApps resolve that record to confirm the association deterministically: either the record exists and the agent is verified, or it does not.
On Solana, the Solana Attestation Service (live since May 2025) takes a credentials-based approach where trusted issuers attach verifiable attestations to wallet addresses. Trusta.AI is building a trust network covering AI agent identities across chains, including Solana. A formal agent-specific identity standard on Solana does not yet exist, but the pieces are being assembled.
Beyond these two ecosystems, approaches diverge further. Fetch.ai, the infrastructure layer behind the Artificial Superintelligence Alliance (a coalition of Fetch.ai, SingularityNET, Ocean Protocol, and CUDOS) handles agent registration and discoverability through its Almanac Contract a smart contract on its Cosmos-based chain that lets agents register, be discovered, and communicate across the ecosystem.
Ledger's hardware identity roadmap takes a different angle, anchoring agent signing authority to a physical secure element rather than a software registry. MoonPay has already integrated this, making it the first CLI wallet where users verify and approve every agent transaction on-device via Ledger hardware, across Ethereum, Solana, and all major chains.
Each of these approaches reflects the priorities of the ecosystem it emerged from. ERC-8004 is built for open permissionless environments where composability matters. Attestation services suit credential-heavy ecosystems where issuers already exist. Hardware binding suits deployments where agents control real assets and human approval gates add an extra security layer.
AI Payments and Settlement
Agent-to-agent payments are not a new idea. Olas, launched in 2021, built one of the first on-chain systems for AI agents. By Q1 2026, the network was processing over 800 daily active agents and had accumulated 11.7 million agent-to-agent transactions across nine chains.
The new generation of agent payment infrastructure is solving the same problem at a different layer and a much larger scale, and it got there faster than most expected.
The most direct evidence of that speed is Coinbase's x402 protocol, launched in May 2025. It revives the HTTP 402 status code (a rarely used "Payment Required" response that has existed in the HTTP spec since the mid-90s) as a machine-native payment trigger. An agent requests a resource, receives a 402 response with payment details, pays instantly in stablecoins, and gets access. No human approval, no invoicing, no integration overhead.
In the last 30 days alone, x402 processed 75.41 million transactions worth $24.24 million in volume, with over 94,000 buyers and 22,000 sellers actively using the protocol. It now works on all EVM-compatible chains, Solana, and other platforms.
In April 2026, the x402 team released a meaningful update: a "Upto" payment scheme replacing flat fees with usage-based pricing for AI compute. Previously, x402 only supported fixed payments, which works for deterministic APIs but breaks down for variable-cost services like LLM inference or compute-time billing. The update lets agents pay only for what they actually consume. It's a small change technically; architecturally it eliminates the need for API keys and subscriptions, replacing them with instant, pay-per-use on-chain payments.
Volume at scale is useful. Authorization is a different problem. That's where Google's AP2, released in September 2025, comes in. Built as an extension of A2A and MCP, it doesn't move money - it defines the conditions under which an agent is permitted to move money on a user's behalf. Users sign cryptographic Intent Mandates upfront that specify exactly what an agent can spend, on what, within what price limits, and for how long. At checkout, a Cart Mandate locks in the exact items and price, with the user's signature serving as non-repudiable proof of intent. A third credential, the Payment Mandate, travels with the transaction to the payment network and issuer, signaling whether a human was present or the agent acted autonomously. Every payment carries an audit trail linking back through all three.
Launched with over 60 institutional partners, including Mastercard, PayPal, and Coinbase, AP2 has since expanded into Europe through a Nexi Group and Google Cloud MoU signed in March 2026. For the crypto rail specifically, Google extended AP2's core constructs with Coinbase to launch the A2A x402 extension a solution for agent-based stablecoin payments.
The most complete execution layer to emerge in early 2026 is the Machine Payments Protocol (MPP), launched in March 2026 as open-standard infrastructure designed to enable autonomous AI agents to pay for services directly. MPP runs on Tempo, a blockchain built by Stripe and Paradigm specifically for stablecoin payments and 24/7 settlement, which raised $500 million before going live. Where x402 handles single HTTP payments and AP2 defines what agents are authorized to do, MPP sits between the two: session-based payment negotiation, multi-method settlement in stablecoins or fiat, and Stripe's compliance stack (fraud protection, tax calculation, and reporting) applied to every machine transaction. It is backwards-compatible with x402 and has been submitted to the IETF as an open standard.
The custody question is handled separately by a growing category of wallets purpose-built for agent use. Two security architectures dominate: MPC (Multiparty Computation), which distributes transaction signing across multiple parties and TEEs (Trusted Execution Environments), which execute and sign transactions inside hardware-isolated enclaves where keys never leave the boundary. Both enforce user-defined spending rules at the cryptographic level rather than the application level. Here are a few examples:
Cobo Agentic Wallet pairs MPC with a proprietary "Pact" authorization framework and “Recipe” execution layer that inspects each transaction against user-defined policies before signing - even severe prompt injection cannot produce a valid signature outside the permitted scope.
Binance Agentic Wallet runs as a ring-fenced sub-wallet under a user's Binance account; its balance is fully isolated from the main wallet, and the agent never holds the private key directly. Built on Binance's MPC Keyless infrastructure, the key is never fully reconstructed on any single device. Users set daily limits, token scope, and high-risk transaction handling in the Binance app; anything outside those rules is automatically rejected or escalated for confirmation. Outbound transfers are restricted to addresses already in the user's address book.
Coinbase Agentic Wallets store private keys inside Trusted Execution Environments (TEEs) on Coinbase's infrastructure - the key never leaves the enclave, never touches the agent's code, and cannot be extracted even by Coinbase operators. Transaction signing, spending limit enforcement, and KYT (Know Your Transaction) screening all happen inside the same boundary: every transaction is scored against sanctions and known scam contracts before it goes on-chain, and anything flagged is blocked before the agent proceeds. Users set session caps and per-transaction limits upfront; the agent cannot exceed them programmatically.
MPC distributes trust across multiple parties with no single point of failure but requires multiple signing rounds, which adds latency. TEEs execute faster within a single hardware boundary, but that boundary is centralized in one operator's infrastructure. Most production deployments now combine both, treating them as complementary layers rather than alternatives.
AI Compute and Training
Running an AI model at scale is expensive, and getting more so. For example, AWS raised the price of its GPU instances by more than 15% in January 2026. GPU shortages persist. For most teams, the hyperscaler bill is now the largest line item in their AI budget, and the gap between what they're paying and what the hardware actually costs keeps widening. Decentralized compute networks exist because that gap is real and increasingly large enough to justify a different approach.
That cost pressure is pushing developers toward decentralized alternatives, but it's also doing something less obvious: pushing traditional distributed compute companies toward blockchain-native infrastructure. Salad is a distributed cloud company that operates 450K+ worldwide earning nodes and 60,000 active GPUs across 190+ countries for AI inference, rendering, and scientific research.
Rather than building its own token or chain, Salad selected Render Network, which was built to democratize high-end GPU rendering for generation 3D content creation, as its exclusive on-chain payments layer, moving node rewards and customer payments via RENDER tokens (an estimated $2.3M/year settling through blockchain rails rather than centralized accounts). For Salad's node operators, the "Chefs" who contribute their machines, it means self-custodied earnings and faster payouts.
Akash Network tells the same story differently. It is a decentralized cloud marketplace where providers list hardware and developers bid for it, with costs running 70% below AWS. In 2025, total deployments jumped from 553,000 to 3.1 million, but active deployments simultaneously fell 69%. That sounds contradictory until you understand what it means: agents are spinning up compute for a specific task, running it, then releasing the resources - renting by the minute, not the month. That pattern wasn't designed into Akash, it emerged from how developers are actually building. The project io.net does something similar but specialized: it aggregates 30,000+ GPUs across 130+ countries into on-demand clusters on Solana, built for burst AI workloads that need to spin up fast and scale quickly. Aethir takes the enterprise route, a decentralized GPU cloud focused on institutional clients, with over 435,000+ CPU, demonstrating that this infrastructure can meet SLA requirements well beyond the crypto-native world.
At the specialized end sits Qubic - not a GPU marketplace but a compute-focused L1 built specifically for AI workloads, with no gas fees, no rollups, and a CertiK-verified 15.52M TPS on live mainnet. Yes, 15.5m in TPS sounds like something superluminal. For users who need AI without data exposure, PIN AI runs personal agents inside TEEs - hardware-isolated enclaves where a model operates on private data and the blockchain coordinates access without ever seeing what's inside.
Decentralized training is where the boldest claims have historically lived and where proof has been hardest to produce. That changed in 2025. 0G Labs is a decentralized AI infrastructure chain, its own L1, compute layer, and storage network built as a single stack. In July 2025 it trained DiLoCoX-107B, a 107-billion-parameter model, across distributed infrastructure in partnership with China Mobile, achieving 357x better communication efficiency than standard methods over ordinary 1 Gbps connections -Â the largest model ever trained on decentralized infrastructure. In March 2026, 0G published a technical framework explaining how TEE verification applies to decentralized training and why it is important.
The rest of the field is catching up. Bittensor is a decentralized marketplace where anyone can contribute an AI model or compute and earn rewards based on how useful their contribution is - no company owns it, no single team controls what gets trained. Its Subnet 3 (Templar) completed Covenant-72B, a 72.7-billion-parameter model trained permissionlessly across the network in early 2026, with no single organization controlling the process or owning the result.
Nous Research is an open-source AI lab that, in early 2025, built Psyche, a decentralized training network coordinated by smart contracts on Solana with no human intermediary, where all runs are fully public and trackable on the Psyche dashboard. Its Consilience-40B model was the largest distributed pre-training run ever at the time, proving that models at that scale can be trained across idle GPUs without central infrastructure.
The common thread across all of it is that none of these runs required a data center contract, a hyperscaler relationship, or a centralized coordinator. The infrastructure assembled itself.
AI Data, Storage, and Rights
Most AI infrastructure has a split-stack problem. Compute lives on one provider, storage on another, training data licensed through a third, and rights handled off-chain by lawyers or not at all. Every boundary between those layers costs money in egress fees, latency, and manual integration work. At the scale agents operate, that friction compounds fast. The decentralized stack doesn't eliminate the split, but it's starting to build the bridges.
For permanent archival: model weights, research datasets, and compliance records - Irys launched mainnet in November 2025 as the programmable datachain (originally Bundlr) Arweave's upload middleware, now an independent L1 where data and smart contracts operate on the same layer, eliminating the round-trip between storage and compute.
For active training datasets: Walrus launched mainnet in March, 2025 as a Sui-based decentralized storage protocol built with AI background in mind. It uses RedStuff erasure coding, 4–5x more efficient than simple replication. Its MemWal SDK in beta gives AI agents a verifiable long-term memory layer - durable, typed memory spaces (conversations, checkpoints, reasoning traces) with programmable access control, ownership models, and full portability across agent frameworks. BNB Greenfield integrates storage directly with smart contracts on BNB Chain - data ownership as non-transferable NFTs, access permissions governed onchain, designed for datasets that need to interact with DeFi and dApps on the same chain.
For hot, real-time workloads, Akave operates on top of Filecoin with S3-compatible access, smart contract-based control, and native MCP integration for agentic pipelines. Storacha takes the same approach - a hot storage layer on Filecoin targeting CDN-level retrieval speeds, already handling petabytes, with an MCP server and Storacha AI for AI agent memory. At the same time Filecoin is not left behind and introduced Filecoin Onchain Cloud in November 2025 - decentralized cloud platform that brings verifiable storage, fast retrieval, and programmable payments fully on-chain.
AIOZ W3S is part of the broader AIOZ DePIN stack, S3-compatible object storage across P2P nodes with built-in CDN, sitting alongside AIOZ AI Â compute on the same infrastructure.
Having the infrastructure to store data at scale solves one half of the problem. The other half is access, and that's where storage ends and a harder negotiation begins. The gap between "data exists" and "data is usable" is where most AI projects get stuck.
Three protocols are closing that gap from different directions.
Ocean Protocol solves it from the provider side: the model travels to the data, not the other way around. Training and inference run inside the provider's environment, only results leave. Since launching Ocean Nodes, the network has grown to 1.7M nodes across 70+ countries -Â with GPU compute now folding into the same node layer, so storage and compute share a single addressable surface rather than two separate spaces. Vana tackles the same problem from the opposite end: individuals pool their own data into DataDAO that collectively governs and monetizes it for AI training, with VRC-20 data tokens now tradeable on Solana.
Sahara AI takes the enterprise angle with a full-stack approach: a Cosmos SDK L1 with EVM compatibility that tokenizes the entire AI development lifecycle - datasets, models, and agents registered as on-chain assets with verifiable provenance and automated royalty splits. Its three layers cover the full pipeline: Data Services Platform for crowdsourced data labeling and refinement, an AI Developer Platform for building and deploying agents without infrastructure overhead, and an AI Marketplace where datasets and models can be licensed or traded. 40+ enterprise partners including Microsoft, Amazon, and CharacterAI.
Chainbase is the indexing layer underneath much of this: 200+ chains indexed into query-ready signals, 500B+ transactions processed, 240M+ queries per day across 24,000+ projects - built on a dual-chain architecture combining Cosmos for coordination and EigenLayer for economic security. Its core primitive is Manuscripts, developer-written data processing scripts that clean and structure raw chain data, deployable across the network and monetizable by their creators. Agents and dApps query the result in real time via SQL, REST, or MCP without running their own nodes.
The indexing and access layer makes data queryable. What it doesn't resolve is whether any given query is authorized, and at agent scale, that question moves from the legal department to the protocol layer.
An agent that generates derivative content, trains on copyrighted data, or licenses music for a product needs to know - at call time, not after a legal review - whether it's authorized to do so and what it owes. Story Protocol launched its mainnet in February 2025 to make that possible: creative works register as on-chain objects with programmable licensing terms, so permissions are machine-readable rather than buried in PDFs. In January 2026, Story and OpenLedger formalized this into a training standard: models prove how licensed IP (Intellectual Property) was used, royalties are distributed automatically, and no intermediary is required. Projects like GenoBank's BioIP show what this looks like in operation: 7,000+ genomic accounts, 150+ research partnerships, $6.9M in tokenized genomic IP, agents accessing specific gene sequences via micropayments and revocable time-limited links, every access logged on-chain. A $10M fund with OKX Ventures is backing the next wave of projects building on the same model.
The creator economy is where this becomes most concrete. Camp Network launched mainnet in August 2025 with Origin Framework as its IP and licensing layer, and mAItrix as the agent layer on top - where agents don't just consume licensed IP, they are IP. Every agent registers as an IPNFT at creation: cryptographic ownership, programmable licensing terms, and automatic royalty distribution built in from the start. In January 2026, Camp partnered with Unchained Music to power Unchained Licensing using Origin, the first production implementation proving a real chain of custody for music rights, from release through reuse, with every derivative work automatically inheriting provenance from its source and settlement in USDC. It's a small example of a larger shift: the legal and operational overhead that used to sit between an agent and the content it touches is being absorbed into the protocol itself.
Storage, data, and rights are the three dependencies that have kept AI agents tethered to human infrastructure. The protocols above don't eliminate that dependency - they encode it. What's being built next is the layer that actually runs the agents on top of it.
AI Agent Frameworks
The infrastructure layers: compute, storage, data, and rights don't run themselves. Agent frameworks are the coordination layer on top: how agents discover each other, execute tasks, get paid, and build reputation over time.
By early 2026, the space had fragmented into distinct functional roles rather than consolidating around a single stack. Virtuals Protocol turns agents into publicly co-owned economic actors. Holders receive governance rights and a share of the agent's revenue. Unlike assistants that wait for prompts, Virtuals agents run continuously, coordinate with other agents, and generate real commercial output - $4.08M in total agent revenue and 2.27M completed jobs to date, across 29,691 active wallets.
ALMANAK sits closer to the application layer and lets developers build and deploy DeFi trading agents without starting from scratch. You describe what you want - swap, borrow, provide liquidity, and its Intent Compiler translates that into optimized on-chain transactions automatically. Before anything goes live, a built-in backtesting engine runs simulations and stress tests against historical data. It works across 12 chains and connects natively to Uniswap, Aave, Morpho, Polymarket, and 20+ other protocols. Alongside these, a growing ecosystem of platforms: Theoriq, Wayfinder, TALUS, Nevermined, Questflow and others, covers workflow automation, on-chain credit scoring, and agent-native execution environments. The ecosystem is fragmented because agents doing different things need fundamentally different infrastructure.
What's accelerating capability across all of them are composable skills - loadable modules that extend what an agent can do without modifying how it's built. Uniswap's 7-module Skills SDK, released in February 2026, was the first protocol-native agent toolkit from a major DeFi protocol. The Solana Foundation's Agent Skills toolkit, released in April 2026, establishes a structured capability registry treating agents as first-class network participants.
Alongside native integrations, UnifAI Network, an AI-native DeFi automation protocol, provides a complementary route: through integration with OpenClaw, an open-source autonomous agent platform. Its entire DeFi infrastructure becomes accessible as a single unified skill covering 45+ protocols including Aave, Uniswap, Hyperliquid and Polymarket.
The deployment picture at the exchange layer is equally direct. In Q1 2026, every major crypto exchange provided an agentic product: Binance AI Pro on the OpenClaw ecosystem, OKX Agent Trade Kit connecting AI assistants directly to exchange execution, Coinbase Agentic Market, Bybit AI Hub, and Kraken CLI as the first AI-native command-line interface for trading crypto, stocks, forex, and derivatives.
Crypto reached execution first because the infrastructure already existed: programmable contracts, 24/7 markets, and no intermediary layers between an agent's decision and the transaction that follows. As a result, new DeFi protocols launching in early 2026 made agent-first design a core architectural requirement.
AI Verification Stack
For most of crypto's history, verification meant economic deterrence: validators stake capital, misbehavior gets slashed, and honest behavior wins on expectation. That model works well for consensus, but that doesn’t work for AI agents. The infrastructure layer is now shifting from probabilistic security to cryptographic guarantees across re-execution, zero-knowledge proofs, training verification.
Re-execution and Deterministic Inference
The most straightforward way to verify that a computation was done correctly is to do it again. If two independent parties run the same task and get the same result, confidence goes up. If they disagree, at least one of them is wrong, and with economic stakes attached, the incentive to be right is real. This is the logic EigenCloud applied when it introduced Actively Validated Services: distribute tasks across a network of restaked operators, compare outputs, and slash the ones that deviate.
That approach works well for deterministic software. AI inference is harder, because many modern LLM deployments can produce different byte-level outputs even when given the same input, which makes straightforward re-execution difficult in settings that require strong verification.
EigenCloud is building around that problem with three services. EigenDA handles data availability, EigenCompute provides a verifiable execution layer, and EigenAI is designed to make inference reproducible enough to verify.
According to EigenCloud’s technical materials, it reduces variance by tightly controlling the inference environment, including hardware and execution behavior, so identical inputs produce identical output bytes. EigenAI reports that in 10,000 inference runs, every SHA256 hash matched, with about 1.8% added latency, presenting that tradeoff as the cost of verifiability.
Once inference is deterministic, verification becomes much simpler. As the model is moving through an optimistic verification, we can treat AI with the same skepticism and rigor as a financial record. This approach keeps steady-state costs low, approaching normal inference speeds, because the heavy lifting of re-execution only happens when a result is actually challenged. Since there’s no room for "maybe," a single honest verifier can catch a mismatch and trigger economic penalties that make cheating a losing trade. By securing this process within hardware enclaves, privacy is preserved even under audit, finally shifting the industry from a "trust me" to the cold certainty of cryptographic proof.
Orchestration and Onchain AI
If deterministic inference is the foundation, Chainlink all-in-one oracle platform is the connective tissue. Its Chainlink Runtime Environment (CRE), which went live in November 2025, serves as an orchestration layer. It allows developers to build custom workflows that don't just "get data" but coordinate entire offchain AI tasks.
Chainlink’s approach is about bringing "proofs" to the existing chain. It uses a mix of zkML (zero-knowledge machine learning), TEEs (secure hardware enclaves), and provenance signatures to verify that an AI didn’t just hallucinate a result or get tampered with before it hit the smart contract. Their Verifiable AI Stack basically maps out how these components work together - spanning everything from the raw verification of the model (the L2 "Verification" layer) to the final application where the agent actually acts (the L4 "Integration" layer).
The Mathematical Truth of zkML
While re-execution is about an auditor checking the work, Zero-Knowledge Machine Learning (zkML) is about the math itself becoming the final judge.
This movement found its "genesis" moment in March 2024, when Modulus Labs recorded the first on-chain LLM output. They successfully proved a 1.5 billion parameter GPT2-XL model, and inscribed the result in Ethereum block 19427725. It was an expensive, 200+hour proof that required 128-core CPU and 1TB RAM, but it broke the idea that large models were fundamentally impossible to verify mathematically.
Today, Inference Labs is scaling this concept through a modular architecture that gives developers a choice of "mathematical proofs". They have introduced JSTprove, a specialized toolkit built on Polyhedra Network’s Expander backend for scalable proof generation and verification. The design of JSTprove allows for easy integration into existing AI workflows, providing a transparent and reproducible way to check for consistency with given models.
Training Markets
While checking a final inference matters, Gensyn looks at the whole process, from initial training to the final decision. Instead of trusting a single big lab to build everything, they have built an open system where models compete in what they call Information Markets. Gensyn operates on a custom EVM Layer-2 rollup built with the OP Stack (Bedrock) and this whole environment is supported by three main pieces of tech that work together behind the scenes.
First, there is AXL (P2P network node), which handles the communication, allowing machines to interact and share data directly without needing to route through a central server or manage a cloud account. It exposes a simple HTTP API for fire-and-forget messaging, network topology discovery, and native support for MCP and A2A agent protocols.
Then there is REE (Reproducible Execution Environment), the verification layer that makes sure every computation was performed as intended. It supports 40+ models across 20+ GPU targets, covering the RTX 30-, 40-, and 50-series and every generation of data-centre hardware from Volta to Blackwell.
This ensures that no matter what hardware a model runs on, the output is identical down to the last bit, meaning any disagreements can be caught and resolved automatically. Finally, everything is anchored to a shared record on the Chain, giving every person, model, or agent a permanent identity to build up their reputation and stake over time.
In this setup, the market itself acts as the teacher: models that provide accurate answers earn rewards to fund their growth, while those that fail lose their stake in a self-correcting cycle where the best information wins.
With the recent mainnet launch in April 2026, the protocol has moved from a research project to a live settlement layer for machine intelligence that is now accessible with Delphi, a set of open tools for deploying and participating in information markets.
Where This Leads Us
The shared infrastructure stack is real and maturing quickly. Agents need identity, reputation, payments, data access, and verified execution. Web3 has made meaningful contributions to most of these in the last years - payments and settlement most concretely, identity in a nascent but formally specified and increasingly hardware-anchored form, verifiable compute at the early-production edge.
What's missing is not infrastructure primitives - it's the full-stack composition of those primitives into systems that agents can rely on end-to-end without human intervention at the boundaries. Getting all these elements to compose reliably, with consistent security guarantees, is the 2026–2027 engineering challenge. The projects building toward it are doing real work. The timeline forecasts attached to that work should be read as incentivized optimism until the onchain activity says otherwise.
The agent economy is not a metaphor for crypto's next cycle. It is a specific set of infrastructure requirements that some Web3 protocols happen to be well-positioned to meet and some are not. The distinction will matter more as the requirements become concrete.
The information provided by DAIC, including but not limited to research, analysis, data, or other content, is offered solely for informational purposes and does not constitute investment advice, financial advice, trading advice, or any other type of advice. DAIC does not recommend the purchase, sale, or holding of any cryptocurrency or other investment.
