From 84f5967388bf14c2ea31bbf2820341e3293f419c Mon Sep 17 00:00:00 2001 From: Ori Pomerantz Date: Mon, 19 Jan 2026 12:38:08 -0600 Subject: [PATCH 1/4] AI agent updates --- public/content/ai-agents/index.md | 44 +++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/public/content/ai-agents/index.md b/public/content/ai-agents/index.md index 506b10723b3..982de76a093 100644 --- a/public/content/ai-agents/index.md +++ b/public/content/ai-agents/index.md @@ -45,6 +45,50 @@ These factors transform AI agents from simple bots into dynamic, self-improving +## Verifiable AI {#verifiable-ai} + +AI agents running offchain often behave like “black boxes”-their reasoning, inputs, and outputs can’t be independently verified. Ethereum changes that. By anchoring agent behavior onchain, developers can build agents that are *trustless*, *transparent*, and *economically autonomous*. The actions of such agents can be audited, constrained, and proven. + +### Verifiable inference {#verifiable-inference} + +AI inference traditionally happens offchain, where execution is cheap but model execution is opaque. On Ethereum, developers can pair agents with verifiable computation using several techniques: + +- [**zkML (zero‑knowledge machine learning)**](https://opengradient.medium.com/a-gentle-introduction-to-zkml-8049a0e10a04) lets agents prove that a model was executed correctly without revealing the model or inputs. + +- [**TEE (trusted execution environment) attestations**](https://en.wikipedia.org/wiki/Trusted_execution_environment) allow hardware‑backed proofs that an agent ran a specific model or code path + +- **Onchain immutability** ensures these proofs and attestations can be referenced, replayed, and trusted by any contract or agent. + +## Payments, attestations, and agent‑to‑agent commerce with x402 {#x402} + +The [x402 protocol](https://www.x402.org/), deployed on Ethereum and L2s, gives agents a native way to pay for resources and interact economically without human intervention. Agents can: +- Pay for compute, data, and API calls using stablecoins. +- Request or verify attestations from other agents or services. +- Participate in agent‑to‑agent commerce, buying and selling compute, data, or model outputs. + +x402 turns Ethereum into a programmable economic layer for autonomous agents, enabling pay‑per‑use interactions instead of accounts, subscriptions, or centralized billing. + +### Agentic finance security {#agentic-finance-security} + +Autonomous agents need guardrails. Ethereum provides them at the wallet and contract level: + +- [Smart accounts (EIP‑4337)](https://eips.ethereum.org/EIPS/eip-4337) let developers enforce spending limits, whitelists, session keys, and granular permissions. +- Programmed constraints in smart contracts can restrict what an agent is allowed to do. +- Inference‑based limits (e.g., requiring a zkML proof before executing a high‑risk action) add another layer of safety. + +These controls enable the deployment of autonomous agents that are not unbounded. + +### Onchain registries: ERC-8004 {#erc-8004} + +[ERC 8004](https://eips.ethereum.org/EIPS/eip-8004) is an emerging standard (currently in peer review) that proposes onchain registries for agent identity, capabilities, and attestations. + +If adopted, it could provide: +- A shared, trustless directory of agents +- Standardized attestation formats +- A foundation for “trustless agent infrastructure” directly on the Ethereum mainnet + +This would make it easier for agents to discover, verify, and transact with each other in a fully decentralized environment. + ## AI agents on Ethereum {#ai-agents-on-ethereum} We're beginning to explore the full potential of AI agents, and projects are already leveraging the synergy between AI and blockchain—particularly in transparency and monetization. From 409c94e036f527f2acd92e046fe48f2222af24fd Mon Sep 17 00:00:00 2001 From: Ori Pomerantz Date: Mon, 19 Jan 2026 15:06:56 -0600 Subject: [PATCH 2/4] Revise section title for x402 payments and commerce Updated section title for clarity. --- public/content/ai-agents/index.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/public/content/ai-agents/index.md b/public/content/ai-agents/index.md index 982de76a093..0be19dedf75 100644 --- a/public/content/ai-agents/index.md +++ b/public/content/ai-agents/index.md @@ -59,7 +59,7 @@ AI inference traditionally happens offchain, where execution is cheap but model - **Onchain immutability** ensures these proofs and attestations can be referenced, replayed, and trusted by any contract or agent. -## Payments, attestations, and agent‑to‑agent commerce with x402 {#x402} +## Payments, and commerce with x402 {#x402} The [x402 protocol](https://www.x402.org/), deployed on Ethereum and L2s, gives agents a native way to pay for resources and interact economically without human intervention. Agents can: - Pay for compute, data, and API calls using stablecoins. @@ -140,4 +140,4 @@ The distinction between AI agents and AI bots can sometimes be confusing, as bot ## You can build your own AI agent {#you-can-build-your-own-ai-agent} - \ No newline at end of file + From 35fd228b742f49cb11a00f8ee593ba1ab3eb941f Mon Sep 17 00:00:00 2001 From: Paul Wackerow <54227730+wackerow@users.noreply.github.com> Date: Mon, 19 Jan 2026 20:49:18 -0800 Subject: [PATCH 3/4] chore: syntax/punctuation clean up --- public/content/ai-agents/index.md | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/public/content/ai-agents/index.md b/public/content/ai-agents/index.md index 0be19dedf75..eece9f18bf4 100644 --- a/public/content/ai-agents/index.md +++ b/public/content/ai-agents/index.md @@ -47,45 +47,45 @@ These factors transform AI agents from simple bots into dynamic, self-improving ## Verifiable AI {#verifiable-ai} -AI agents running offchain often behave like “black boxes”-their reasoning, inputs, and outputs can’t be independently verified. Ethereum changes that. By anchoring agent behavior onchain, developers can build agents that are *trustless*, *transparent*, and *economically autonomous*. The actions of such agents can be audited, constrained, and proven. +AI agents running offchain often behave like "black boxes"—their reasoning, inputs, and outputs can’t be independently verified. Ethereum changes that. By anchoring agent behavior onchain, developers can build agents that are _trustless_, _transparent_, and _economically autonomous_. The actions of such agents can be audited, constrained, and proven. ### Verifiable inference {#verifiable-inference} AI inference traditionally happens offchain, where execution is cheap but model execution is opaque. On Ethereum, developers can pair agents with verifiable computation using several techniques: -- [**zkML (zero‑knowledge machine learning)**](https://opengradient.medium.com/a-gentle-introduction-to-zkml-8049a0e10a04) lets agents prove that a model was executed correctly without revealing the model or inputs. - -- [**TEE (trusted execution environment) attestations**](https://en.wikipedia.org/wiki/Trusted_execution_environment) allow hardware‑backed proofs that an agent ran a specific model or code path - -- **Onchain immutability** ensures these proofs and attestations can be referenced, replayed, and trusted by any contract or agent. +- [**zkML (zero-knowledge machine learning)**](https://opengradient.medium.com/a-gentle-introduction-to-zkml-8049a0e10a04) lets agents prove that a model was executed correctly without revealing the model or inputs +- [**TEE (trusted execution environment) attestations**](https://en.wikipedia.org/wiki/Trusted_execution_environment) allow hardware-backed proofs that an agent ran a specific model or code path +- **Onchain immutability** ensures these proofs and attestations can be referenced, replayed, and trusted by any contract or agent ## Payments, and commerce with x402 {#x402} The [x402 protocol](https://www.x402.org/), deployed on Ethereum and L2s, gives agents a native way to pay for resources and interact economically without human intervention. Agents can: -- Pay for compute, data, and API calls using stablecoins. -- Request or verify attestations from other agents or services. -- Participate in agent‑to‑agent commerce, buying and selling compute, data, or model outputs. -x402 turns Ethereum into a programmable economic layer for autonomous agents, enabling pay‑per‑use interactions instead of accounts, subscriptions, or centralized billing. +- Pay for compute, data, and API calls using stablecoins +- Request or verify attestations from other agents or services +- Participate in agent-to-agent commerce, buying and selling compute, data, or model outputs + +x402 turns Ethereum into a programmable economic layer for autonomous agents, enabling pay-per-use interactions instead of accounts, subscriptions, or centralized billing. ### Agentic finance security {#agentic-finance-security} Autonomous agents need guardrails. Ethereum provides them at the wallet and contract level: -- [Smart accounts (EIP‑4337)](https://eips.ethereum.org/EIPS/eip-4337) let developers enforce spending limits, whitelists, session keys, and granular permissions. -- Programmed constraints in smart contracts can restrict what an agent is allowed to do. -- Inference‑based limits (e.g., requiring a zkML proof before executing a high‑risk action) add another layer of safety. +- [Smart accounts (EIP-4337)](https://eips.ethereum.org/EIPS/eip-4337) let developers enforce spending limits, whitelists, session keys, and granular permissions +- Programmed constraints in smart contracts can restrict what an agent is allowed to do +- Inference-based limits (e.g., requiring a zkML proof before executing a high-risk action) add another layer of safety These controls enable the deployment of autonomous agents that are not unbounded. ### Onchain registries: ERC-8004 {#erc-8004} -[ERC 8004](https://eips.ethereum.org/EIPS/eip-8004) is an emerging standard (currently in peer review) that proposes onchain registries for agent identity, capabilities, and attestations. +[ERC-8004](https://eips.ethereum.org/EIPS/eip-8004) is an emerging standard (currently in peer review) that proposes onchain registries for agent identity, capabilities, and attestations. If adopted, it could provide: + - A shared, trustless directory of agents - Standardized attestation formats -- A foundation for “trustless agent infrastructure” directly on the Ethereum mainnet +- A foundation for "trustless agent infrastructure" directly on the Ethereum mainnet This would make it easier for agents to discover, verify, and transact with each other in a fully decentralized environment. From f709cb9a070996c9e7be660992730e03977ae85a Mon Sep 17 00:00:00 2001 From: Paul Wackerow <54227730+wackerow@users.noreply.github.com> Date: Mon, 19 Jan 2026 20:50:14 -0800 Subject: [PATCH 4/4] chore: prettier auto-format --- public/content/ai-agents/index.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/public/content/ai-agents/index.md b/public/content/ai-agents/index.md index eece9f18bf4..d1ea415adb4 100644 --- a/public/content/ai-agents/index.md +++ b/public/content/ai-agents/index.md @@ -6,12 +6,12 @@ lang: en template: use-cases emoji: ":robot:" sidebarDepth: 2 -image: /images/ai-agents/hero-image.png +image: /images/ai-agents/hero-image.png alt: People gathered at terminal table summaryPoint1: AI that interacts with blockchain and trades independently summaryPoint2: Controls onchain wallets and funds -summaryPoint3: Hires humans or other agents for work -buttons: +summaryPoint3: Hires humans or other agents for work +buttons: - content: What are AI agents? toId: what-are-ai-agents - content: Explore agents @@ -128,11 +128,11 @@ The distinction between AI agents and AI bots can sometimes be confusing, as bot - AI bots are like automated assistants — They follow specific, pre-programmed instructions to perform routine tasks. - AI agents are more like intelligent companions — They learn from experience, adapt to new information, and make decisions on their own. -| | AI agents | AI bots | -| ------------------------- | ------------------------- | ------------------------- | -| **Interactions** | Complex, adaptable, autonomous | Simple, pre-defined scope, hardcoded | -| **Learning** | Learns continuously, can experiment and adapt to new data in real-time | Operates on pre-trained data or fixed rules | -| **Task completion** | Aims to achieve broader objectives | Focuses on specific tasks only | +| | AI agents | AI bots | +| ------------------- | ---------------------------------------------------------------------- | ------------------------------------------- | +| **Interactions** | Complex, adaptable, autonomous | Simple, pre-defined scope, hardcoded | +| **Learning** | Learns continuously, can experiment and adapt to new data in real-time | Operates on pre-trained data or fixed rules | +| **Task completion** | Aims to achieve broader objectives | Focuses on specific tasks only | ## Dive deeper {#dive-deeper}