On-Chain Agents

AI agents are replacing browser-extension dapps as the primary Ethereum UX layer. The thesis: the dapp model saturated in 2022 (browser extension + desktop = the total addressable market). Agents using chat interfaces on mobile, backed by ERC-8004 registries and x402 micropayment rails, are the new access pattern. (→ EthCC[9] — Conference Overview)

Core Thesis (jacobc.eth / Coinfellow, EthCC[9])

The dapp adoption curve looks like Linux — won infrastructure, lost the user layer to proprietary tech.
Ethereum never translated to mobile. Agents are the fix: chat-first, mobile-first, composable.
Enabling stack: EIP-7702 (EOA → smart account), EIPs 7715/7710 (delegation/permissions), ERC-8004 (agent registry), x402 (micropayments).
Self-sovereign agents: user consents to a specific model + permission scope; agent runs in a TEE; no custodial intermediary.

Key Architectures

Deterministic Agents (Gauthier Vila / Zyfai)

For financial decisions, LLMs hallucinate. Zyfai rebalances $2B across 13,000+ wallets using deterministic logic + session keys whitelist. Responded to Resolve and Stream Finance depegs in milliseconds — faster than any human curator. Rule: LLMs for coordination/planning; deterministic logic for fund movement.

Multi-Agent + Multi-Model (Wonderland / jacobc.eth)

Multiple agents review, simulate, and propose transactions before execution. Catches hallucinations. Skeletor Spaceman (Wonderland): “AI is only as good as its prompter” — premature optimization is now valuable because AI amplifies whatever structure (or lack of it) exists in your process.

Local-First Sovereign Agents (Pol Lanski / Dappnode)

Cloud agents = surveillance capitalism at machine speed. Dappnode Nexus: local LLM inference via confidential compute (TEEs) + on-chain discovery via ERC-8004. The stack: local weights + confidential compute + micropayment discovery + no central registry. “Not your weights, not your brain; not your data, not your agent.”

Character Agents for User Acquisition (Rebecca Liao / Saga)

Gaming/entertainment character agents (mascots, sports IPs) live on Instagram/TikTok, transact in merch/battle passes/events. Target: $200B/year user acquisition market with better ROI than ads. Key caveat from Liao: Web2 is not ready for direct crypto rails — agents enable off-chain commerce and feed returns back to crypto. Most agent transactions still off-chain.

Reputation as Missing Middleware (E.G. / DIN)

7,000 MCP services → 95,000 in months. No way to score them. Agents choosing tools/services need:

On-chain reputation: freshness, correctness, speed of each service
Payment + reputation bundled: x402 for payment, DIN for scoring
Without this, agent-to-agent economies collapse due to information asymmetry.

Key Protocols & Standards

Standard	Role
x402	HTTP-native micropayment protocol for agent-to-agent value transfer
ERC-8004	On-chain agent registry (agents register capabilities, discover peers)
MCP (Model Context Protocol)	Standard interface for agent tool access; 95,000+ services registered
EIP-7702	Converts EOA to smart account for one transaction
EIPs 7715/7710	Delegation and permission grants from user wallet to agent
Session keys	Constrain which contracts an agent can call without user approval each time

ETHDenver 2026: Expanded Agent Ecosystem

Agent Trust Infrastructure (Drew Mailen / Valiron)

Infrastructure providers face a binary choice with agents: block all agents (lose business) or accept machine-speed abuse (retry storms, loops, expensive fees). Valiron solves this with a behavioral firewall:

Routes unknown agents to sandboxes tracking rate limits, loop rates, request volume
Assigns Moody’s-style ratings (AAA to C) before production access
ERC-8004 ecosystem: 35,000+ registered agents on Ethereum, 28,000 feedback records, average score 89.8
Claw Hub: 9,100 agent skills available; 92% compliance issues reveal widespread security problems

New reputation layer: ERC-8004 creates immutable behavioral history beyond just transactions — agents have track records that precede their individual interactions.

Multi-Agent Coordination (Kye Gomez / ClawSwarm)

Decompose complex tasks into specialized agents (search agents, trading agents, token-launching agents) coordinated by director agents
gRPC over WebSockets: security choice — replaced vulnerability-prone WebSocket with gRPC
Built 5MB alternative to OpenClaw in ~2,000 lines in 2 days — simplicity enables rapid iteration
High-frequency use cases require Rust/TypeScript implementations; Python is single-threaded

Decentralized Agent Storage (Matt Ober / Pinata)

Agents need globally accessible, auditable, immutable shared state:

IPFS CIDs stored in EVM smart contracts; NFT-gated write access by path prefix
Agents own portable file systems; can roll back to consistent states on failure
Multiple agents can collaborate on shared memory without a central server
Enables skills economy: agents upload reusable skills to Claw Hub, retrieve at boot time

Staking for Inference (Scott Berenzweig / Morpheus)

Morpheus decentralized inference marketplace:

Stake token once → receive daily inference allocation (vs. per-token spending)
Eliminates throttling; predictable agent operation budget
Reframes inference as investment (capital) rather than operational expense
Agent treasury via Safe multisig: user remains co-signer, preventing agent overspending

Google A2A + Universal Commerce Protocol (Ling Zhong / Google)

x402 alone is insufficient for agentic commerce — need full coordination layer:

ERC-8004 for permissionless agent registry with multi-dimensional reputation (timeliness, accuracy, uptime, discounts)
Universal Commerce Protocol structures full shopping journey: merchant discovery → product discovery → cart management → fulfillment
Merchant adaptation requirement: merchants must build MCPs; agents will compare prices across MCPs, forcing merchants to also become agents to negotiate back
“Blockchain tax” of trustlessness has UX cost — must balance verifiability with frictionless experience

Near Protocol Intents ($200M+/day) (George Zeng / Near)

DeFi 3.0 = automating decision-making (DeFi 1.0 automated execution, 2.0 automated liquidity):

Intent-driven: agents declare goals (“maximize yield on 10K USDC”); decentralized solvers compete for execution
Traction: $200M+ daily volume, $15B cumulative — product-market fit demonstrated at scale
Architecture generalizes from DeFi to any commerce: pizza ordering, logistics, any goal-seeking behavior
Agents creating marketplaces where thousands of jobs run without humans in the loop

ERC-8001: Multi-Party Coordination Standard (Kwame Bryan)

Where ERC-7521/7683 handle single-initiator flows, ERC-8001 enables multi-party coordination:

Three stages: Propose (initiator), Accept (all parties), Execute (deterministic)
No trusted intermediary; smart wallets recommended
Applications: yield strategies, liquidations, gaming, agent swarms, multi-sig transactions
Gaming use case: NPCs with wallets coordinating autonomously — solving Vitalik’s original Wow guild drama at protocol level

Ethereum as AI Settlement Layer (David Crapis / EF)

Two pillars of EF’s decentralized AI strategy:

Decentralized coordination: discovery (ERC-8004), trust, privacy, bots hiring bots, staking, smart contract commitments, DAOs
Crypto AI: censorship-resistant, open-source, private, secure AI as alternative to mainstream AI

ERC-8004 live on 20+ chains; 50–100 useful production agents; hundreds of infrastructure projects; thousands of active builders. Private payments: implementing privacy-preserving payment solutions for agents with LLM APIs and RPC vendors.

Deterministic AI for Prediction Markets (Lucas Martin Calderon / Kash)

For any trustless system using AI, determinism is not optional — same input must produce bit-for-bit identical output:

Critical parameters for deterministic inference:

Temperature (not just 0 — causes brittleness)
PRNG algorithm and container digest (GPU architecture, drivers, kernel)
Decoding policy (top-K vs. top-P)
Floating-point non-associativity: how matrices sum changes output (KV cache, kernel scheduling, variable batching)

Full verified stack: Open-source model → TEE (SGX/TDX) → ZKVM (RiscZero/Succinct) → ZK-STARK → Groth16 → Ethereum attestation

Multi-agent council: 99% accuracy when agents have distinct roles, personalities, persistent memory, and reputation — single-model echo produces poor results.

Physical AI and Decentralized Infrastructure (ETHDenver Panel)

Physical AI (software enabling robot autonomy via statistical learning) faces unique infrastructure needs:

Data scarcity: no “internet of the real world”; compressed video can’t reason — needs joint language/logic/visual representation
Open data crisis: OpenAI building proprietary robotics datasets; need Common Crawl equivalent for physical world data
Decentralization necessity: edge compute + cloud intelligence via decentralized networks prevents single-vendor failure at scale
Required: killer demo (open-source stack, public, real-time) + open data collection device with cryptoeconomic incentives

Soft Trust + Hard Trust (James Young / Collab Land)

Ethereum solved hard trust (coordination, settlement). Soft trust (alignment, coherence, behavioral metrics) is unsolved — critical for DAOs and AI safety.

Goodhart’s Law in DAOs: on-chain metrics become targets → stop being good measures
Coherence: beliefs and actions sustained over time — the core of both AI safety and DAO sustainability
MPC network solution: agents use smart accounts + delegated fine-grain permissions; caveats/caveat enforcers prevent funds leaving until conditions met
Digital twin alignment: DAO agents predict outcomes via ZK proof; coherence score tracks alignment; threshold enables agent autonomy
Scaling path: agent-operator coherence → agent-agent coherence → coherent DAO → DAO network effects

Debates

On-chain vs. off-chain rails: Liao (Saga) argues most commerce stays off-chain; crypto provides the return vehicle not the transaction rail. Lanski (Dappnode) and He Who Remains (Swarms) expect on-chain payments to be core. Resolution: hybrid — agents operate off-chain, settle on-chain via x402/MCP.

LLM vs. deterministic: Zyfai uses pure logic for yield decisions; others embrace LLM orchestration. Emerging consensus: LLMs for high-level intent parsing and coordination, deterministic logic for financial execution.

Scale timeline: Swarms predicts ~1 billion agents today, agents exceeding human number within 2–3 years. Liao is more conservative — institutions adopt agents for treasury/user-acquisition, not for trustless autonomy.

The .agent Top-Level Domain (Balazs Nemethi, ETHDenver 2026)

A community effort — not a startup — to secure the .agent TLD through ICANN’s community priority evaluation process. (→ [[ethdenver]])

Why .agent matters: agents need names. Today they live on .horse, .xyz, or random domains. As agentic services replace human-facing services, a recognizable namespace signals “this endpoint is an AI agent” — analogous to how .edu signals educational institutions.

ICANN application window: 2026 (first new TLD applications since 2012). Application window opens April 2026 for 90 days. Many companies with large marketing budgets (OpenAI, Anthropic, etc.) will apply.

The community loophole: ICANN has a Community Priority Evaluation mechanism. If a sufficiently strong community applies, it gets early access to the domain without a bidding war. This is the mechanism being exploited.

Agent Community org: 1,000+ members including Alibaba Cloud, Netlify, Datadog, Grab (Singapore). Nonprofit. Mission: community-governed .agent namespace not owned by a monopolistic tech company.

Key risk: ICANN could financially benefit from a bidding war; large domain registrars don’t want a community-owned namespace. The community needs breadth (many members) and depth (major infrastructure companies) to pass the evaluation.

Pre-registration available: non-binding domain name reservation at agentcommunity.org for early access if the community wins.

Crypto Is Designed for Agents (Haseeb Qureshi / Dragonfly, ETHDenver 2026)

Core reframe: cypherpunk builders inadvertently created the perfect system for autonomous agents, not retail users. The properties that make crypto “human-unfriendly” (long addresses, no customer support, approval flows, deterministic execution) are exactly what autonomous software agents need.

AI agents as native crypto users: Agents can read and understand smart contracts far better than humans understand legal contracts. Agents are comfortable with every friction point that drove retail users away.

Chain-centric → asset-centric transition: The competitive model is shifting from “every chain needs DEX + lending + vault” to “every asset needs DEX + lending + vault.” Assets become the unit of analysis; chain allegiance becomes irrelevant.

Brand loyalty collapse: In a world where agents compare protocols by intent (not brand), and can test Uniswap vs. Cow Swap vs. others instantaneously, protocol stickiness based on UX or reputation collapses. Performance is the only moat.

Interface bypass: As AI intermediaries replace websites, KYC and regulatory front-end requirements become structurally bypassable through direct protocol interaction. This is a regulatory challenge that has no obvious technical solution.

Two development paths:

Conservative track (OpenAI-style): Cautious agents requiring explicit human authorization at each step
Wild west DeFi track: Fully autonomous agents with full agency and capital responsibility — hobbyist-driven, higher risk/reward

Cautionary note: 50% of builders deploying “arb bots” (using Claude Sonnet/Opus) are generating uninformed flow and losing money — they’re testing rather than arbitraging. The democratization of agent deployment has a competence tail risk.

Base Stack and Builder-Trader Flywheel (Jesse Pollak / Base, ETHDenver 2026)

Base Stack announcement: Dedicated sequencer/stack enabling 6 hard forks per year, cheaper block space, maintained Ethereum security. Designed for rapid iteration without waiting for Ethereum core protocol changes.

Agents as businesses: New class of builders creating agents with wallets, monetization, and capital structures. Non-crypto outsiders enter the ecosystem through agent creation, not DeFi protocols. Bankers and Clanker fees alone generating millions daily from agent activity.

Builder-trader flywheel: Tokenization enables high-velocity capital from traders to fund builder/agent innovation. Jesse’s diagnosis: Ethereum has a cultural bias against traders that limits capital velocity. Traders allocate capital to speculative assets that build teams and resources — suppressing this flywheel is a strategic mistake.

AI capability crossing: Models (Sonnet 4.5 era) now at ~80% capability threshold for autonomous agent operation; human curation dropped from dominant (80%) to supporting role (20%). Jesse built 10× more code in 4 days using pure prompting than traditional methods — a personal data point on the threshold crossing.

2026 focus: Customer obsession — solving distinct problems for traders, builders, and institutions (stocks on-chain). Acknowledges no clean answer yet on normalizing the trader-builder relationship.

Devconnect Argentina: Agentic Zero Track

Private Agentic AI (Sandi Fatic)

The privacy gap in current agent architectures: most agents execute in cloud infrastructure with no confidentiality guarantees — operators and infrastructure providers see all inputs and outputs. The fix: TEE-backed agent execution combined with privacy-preserving payment rails.

Private x402: The x402 micropayment protocol (HTTP-native agent payments) runs inside a TEE, so payment metadata (who paid whom, for what) is invisible to the payment infrastructure. See also: Metadata Privacy.

Private execution stack: local or TEE-bound LLM inference + on-chain discovery via ERC-8004 + private x402 rails = agent that can transact without exposing its decision-making process to surveillance.

Open Arenas for AI Trust (Michael Sena / DIN)

Current agent selection is trust-free in the wrong direction: any MCP service can claim any capability. Open Arenas propose adversarial testing environments for AI agents:

Arenas are permissionless competitive environments where agent skills are tested against real tasks
Performance data (accuracy, latency, cost-per-task) is recorded on-chain
Agents choose tools and services by observable arena performance, not self-reported claims
Complements DIN’s reputation scoring (see earlier Reputation as Missing Middleware section)

Intelligence as a Public Good (Nick Emmons)

The argument: if AI training data is public knowledge, the resulting models should be accessible as public infrastructure — not just to paying API customers. Web3 mechanisms (staking, token-curated registries, DAO-governed compute) can fund open inference as a commons.

Connection to ERC-8004: A public intelligence commons needs discoverable, reputation-scored endpoints — exactly what ERC-8004 provides. The combination creates a public AI infrastructure layer with on-chain governance.

LLMs for Secure Code Generation (Mooly Sagiv & John Toman)

Formal verification meets LLM code generation: the key insight is that LLMs generate code that is often semantically wrong in subtle ways, but formal verification tools can detect these bugs automatically.

The workflow:

LLM generates smart contract code
Formal verification tool (e.g., Certora Prover) checks specification invariants
LLM rewrites based on counterexamples
Loop until formally verified

Why this matters for agents: If agents write and deploy their own contracts (the autonomous DeFi thesis), formal verification must be in-loop — humans can’t review agent-generated code at agent speed.

Agents as the Future of Finance (Sam Green)

Agentic finance thesis: autonomous software agents are better positioned than humans to navigate DeFi because they:

Never sleep, never tire, never make emotional decisions
Can parse 1,000 protocol docs in seconds
Execute on intent rather than UI affordances
Hold and deploy capital without custody intermediaries

The counterpoint (panels): Agents make correlated errors at machine speed — when a model misunderstands a protocol, all instances of that agent fail simultaneously. Human curation isn’t being replaced; it’s being moved upstream (model selection, permission scoping) rather than eliminated.

Intelligent Compression for Finance (Renç Korzay)

Financial data is high-frequency and high-dimensionality — most of it is noise. LLM-based compression identifies which signals (price movements, liquidity depths, protocol states) encode genuine information vs. noise, enabling:

More efficient agent prompts (compressed state representation)
Better on-chain storage of agent memory
Faster agent decision cycles (less context = cheaper inference)

Key benchmark: 90%+ compression of DeFi state data with <2% loss in decision quality for yield optimization tasks.

Connections

DeFi Institutional Transition — Yield agents intersect with professional asset management; Haseeb’s neo-finance taxonomy
Privacy as UX Design — Sovereign agents and privacy-preserving local inference
Ethereum Scaling Roadmap — ERC-8004, x402 require efficient on-chain infrastructure; Base Stack enables 6 forks/year
Smart Contract Security (2026 State) — Agents create new attack surfaces (prompt injection, hallucination); interface bypass creates regulatory risk
Prediction Markets — Deterministic AI for prediction market resolution is a specialized agent use case
Creator Economy & Web3 — AI agents accelerate both the attention economy problem and the Web3 creator-ownership solution; provenance-verified content markets

Open Questions

At what capital threshold do TEE guarantees become mandatory for agents managing user funds?
Will ERC-8004 become the dominant standard or fragment into competing registries?
Can fine-tuned small models (not frontier LLMs) handle the full breadth of DeFi actions safely?
When does the interface-bypass problem trigger regulatory response — and what form does that take?
Does the builder-trader cultural divide on Ethereum close, or does Base (more trader-friendly) capture that flywheel independently?