AI content updates

app/[locale]/[...slug]/page-jsonld.tsx

@@ -1,3 +1,5 @@
+import { getTranslations } from "next-intl/server"
+
 import { FileContributor, Frontmatter } from "@/lib/types"
 
 import PageJsonLD from "@/components/PageJsonLD"
@@ -19,28 +21,34 @@ export default async function SlugJsonLD({
   frontmatter: Frontmatter
   contributors: FileContributor[]
 }) {
+  const t = await getTranslations("common")
+
   const url = normalizeUrlForJsonLd(locale, `/${slug}`)
 
-  // Generate breadcrumb items for the slug path
+  // Breadcrumb labels are sourced from `common.json` (same keys the UI
+  // Breadcrumbs component uses), falling back to a title-cased slug fragment
+  // when no translation exists. This keeps JSON-LD localized and avoids
+  // hand-maintained acronym overrides (e.g. "ai-agents" -> "AI agents").
   const breadcrumbItems = [
     {
       "@type": "ListItem",
       position: 1,
-      name: "Home",
+      name: t.has("home") ? t("home") : "Home",
       item: normalizeUrlForJsonLd(locale, "/"),
     },
   ]
 
-  // Add breadcrumb items for each part of the slug path
   const slugParts = slug.split("/").filter(Boolean)
   let currentPath = ""
 
   slugParts.forEach((part, index) => {
     currentPath += "/" + part
+    const defaultName =
+      part.charAt(0).toUpperCase() + part.slice(1).replace(/-/g, " ")
     breadcrumbItems.push({
       "@type": "ListItem",
       position: index + 2,
-      name: part.charAt(0).toUpperCase() + part.slice(1).replace(/-/g, " "),
+      name: t.has(part) ? t(part) : defaultName,
       item: normalizeUrlForJsonLd(locale, currentPath),
     })
   })

app/[locale]/use-cases/page.tsx

@@ -27,7 +27,7 @@ import { getMetadata } from "@/lib/utils/metadata"
 import UseCasesPageJsonLD from "./page-jsonld"
 
 import { ContentLayout } from "@/layouts/ContentLayout"
-import aiAgentsHero from "@/public/images/ai-agents/hero-image.png"
+import decentralizedAiHero from "@/public/images/ai-agents/hero-image.png"
 import ethImg from "@/public/images/eth.png"
 import ethGifCat from "@/public/images/eth-gif-cat.png"
 import ethereumLearn from "@/public/images/ethereum-learn.png"
@@ -199,15 +199,17 @@ export default async function Page(props: { params: Promise<PageParams> }) {
             </div>
           </Section>
 
-          {/* AI agents banner */}
+          {/* Decentralized AI banner */}
           <Callout
-            id="ai-agents"
-            title={t("ai-agents-title")}
-            image={aiAgentsHero}
-            description={t("ai-agents-description")}
+            id="decentralized-ai"
+            title={t("decentralized-ai-title")}
+            image={decentralizedAiHero}
+            description={t("decentralized-ai-description")}
             variant="sm"
           >
-            <ButtonLink href="/ai-agents/">{t("ai-agents-cta")}</ButtonLink>
+            <ButtonLink href="/decentralized-ai/">
+              {t("decentralized-ai-cta")}
+            </ButtonLink>
           </Callout>
 
           {/* Digital ownership and gaming */}

next.config.js

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
 const { PHASE_DEVELOPMENT_SERVER } = require("next/constants")
 
 const createNextIntlPlugin = require("next-intl/plugin")

public/content/ai-agents/ethereum/index.md

@@ -0,0 +1,103 @@
+---
+title: Why Ethereum for AI agents
+description: "Why Ethereum is used as the settlement and coordination layer for AI agents: onchain ownership, verifiable execution, programmable guardrails, and permissionless payments"
+lang: en
+template: ai-agents
+sidebarDepth: 2
+image: /images/ai-agents/hero-image.png
+alt: Why Ethereum for AI agents
+summaryPoints:
+  - "Mature smart accounts and onchain agent identity"
+  - "Programmable guardrails and session keys for bounded autonomy"
+  - "Permissionless access to DeFi, payments, and identity"
+---
+
+AI agents operate across many platforms and networks. This page covers what builders need to understand about building on [Ethereum](/): the specific **technical capabilities** the network provides for autonomous agents, and the **architectural tradeoffs** to weigh before committing to that stack.
+
+**Not every agent deployment belongs on a blockchain like Ethereum.** Agents that are purely read-only, that operate entirely offchain, or that can accept a trusted operator model **may not require the overhead of onchain settlement**.
+
+However, when an agent requires **trustless coordination**, the capabilities below allow agents to **control non-custodial assets, verify their own execution, and interoperate permissionlessly** with open protocols. The capabilities that Ethereum's agent standards provide **replace the need for a trusted operator with code that counterparties can independently verify**.
+
+## Onchain ownership {#onchain-ownership}
+
+An [AI agent's wallet](/ai-agents/wallets/) and its digital assets exist independently on Ethereum. **No unauthorized third party, operator, platform, or cloud provider can unilaterally revoke or freeze them**, because **ownership is enforced by the network itself** rather than by a company's terms of service.
+
+The wallet's controller (whoever holds the keys or owns the smart contract account) retains full authority over those assets. Constraining what the agent itself can spend is a separate concern (covered in the [Programmable guardrails](#programmable-guardrails) section below).
+
+Assets an agent earns, receives as payment, or accumulates during operation are **governed by smart contract code that both the agent's developer and its counterparties can read and verify**. Rules about what the agent can spend and where are **not a policy document on Ethereum; they are executable code** deployed to a network that no single entity operates.
+
+Network-enforced ownership is consequential for [agent deployments](/ai-agents/use-cases/). An autonomous agent integrated into a centralized platform is **only as stable as that platform's continued support and goodwill**. An agent whose treasury and rules live onchain **retains those properties regardless of the agent operator's status**.
+
+## Verifiable execution {#verifiable-execution}
+
+An AI agent running offchain is, **by default, opaque**. Users and counterparties have **no way to confirm that the model producing the agent's outputs is the model it claims to be, or that it ran without tampering**. When an agent takes a consequential action, the only evidence it provides is its own assertion.
+
+Ethereum provides two technical paths for making agent behavior verifiable. **Zero-knowledge machine learning (zkML)** generates a cryptographic proof that a specific model produced a specific output, which a smart contract can verify onchain before acting on the result. **Trusted Execution Environments (TEEs)** run agent logic inside hardware-isolated enclaves and produce attestations that the code executed without tampering. Both approaches allow smart contracts to **verify evidence of correct behavior before releasing funds or executing other consequential actions**.
+
+Each path carries different tradeoffs in latency, trust assumptions, and model size constraints. See [AI agents: Verification](/ai-agents/verification/) for tool comparisons, maturity guidance, and implementation details.
+
+## Programmable guardrails {#programmable-guardrails}
+
+A fundamental risk in deploying autonomous agents is that they hold signing authority over funds. **Giving an agent an unconstrained private key is equivalent to giving it unlimited spending authority**; a **hallucination, a prompt injection, or a logic error** can drain an account.
+
+Ethereum's [account abstraction](/roadmap/account-abstraction/) standards (primarily [ERC-4337](https://eips.ethereum.org/EIPS/eip-4337) and [EIP-7702](/roadmap/pectra/7702/), live on Ethereum Mainnet since the Pectra upgrade, May 2025) allow developers to **replace raw private key control with programmable smart contract wallets**. These wallets enforce spending limits, contract allowlists, and time-bounded **session keys** at the contract level, so a compromised credential cannot drain the account beyond its scoped policy.
+
+For a full comparison of ERC-4337 vs. EIP-7702, session key policy design, SDK implementation examples, and production key management patterns, see the [AI agents: Wallets](/ai-agents/wallets/) page.
+
+## Agent identity and reputation {#agent-identity}
+
+When an agent interacts with a user or with another agent, the counterparty needs a way to **verify what the agent is and what authority it holds**. Centralized identity registries address this by **requiring trust in the registry operator**. Onchain identity standards address it by making registrations **publicly verifiable and censorship-resistant**.
+
+**[The Trustless Agents Standard, ERC-8004](https://eips.ethereum.org/EIPS/eip-8004)** is live on Ethereum Mainnet and 20+ chains since January 29, 2026. It provides **onchain registries for agent discovery, reputation tracking, and output validation**, forming the trust layer that allows agents to participate in complex multi-agent workflows without relying on a centralized directory operator.
+
+For the full registry architecture, contract addresses, ecosystem status, and registration walkthrough, see [AI agents: Identity](/ai-agents/identity/).
+
+## Open composability {#open-composability}
+
+Because Ethereum's protocol layer is permissionless, **an agent can interact with any deployed smart contract**, including decentralized exchanges, lending protocols, prediction markets, data markets, and governance contracts, **without requesting access from the protocol operator**.
+
+Permissionless access to any deployed smart contract means an agent can execute a **complex workflow in a single atomic transaction**: approve a token transfer, execute a swap on a decentralized exchange, deposit the output to a yield protocol, and record the result to an attestation registry. **If any step fails, the entire transaction reverts**. This atomicity property is **not available through standard application programming interfaces (APIs) between centralized services**.
+
+Composability also means that **agent logic can build on existing audited infrastructure rather than re-implementing it**. **Security properties inherited from established Ethereum protocols carry over to the agent's operations**.
+
+<VideoWatch slug="ai-agents-replace-dapps" />
+
+## Scalable payments {#scalable-payments}
+
+Autonomous agents need to pay for compute resources, data feeds, and other agent services without human intervention. Standard financial rails require corporate entities and bank accounts. These are barriers that autonomous code cannot cross.
+
+Ethereum provides a **native, permissionless financial rail for machines**. Agents can hold and spend stablecoins without a bank account, and open protocols like **[x402](https://www.x402.org/)** give any API endpoint a machine-readable way to request and receive payment in a single HTTP exchange. Combined with low-cost [Layer 2](/ai-agents/l2s/) settlement, these primitives enable agents to **independently acquire compute, pay for data, and monetize their own outputs**.
+
+For the full x402 payment flow, stablecoin rail selection, integration code, and alternative payment models, see [AI agents: Payments](/ai-agents/payments/).
+
+## The L2 ecosystem {#the-l2-ecosystem}
+
+Ethereum Mainnet provides the **canonical security and settlement layer**. [Layer 2 networks](/ai-agents/l2s/) extend it by offering **specialized execution environments** with lower fees, faster finality, and capabilities like TEE-based transaction ordering and concentrated agent tooling ecosystems. Because all L2s ultimately settle to Mainnet, an agent's assets and identity remain **anchored to Ethereum's security guarantees** regardless of which L2 it operates on.
+
+See [AI agents: Layer 2s](/ai-agents/l2s/) for an evaluation framework, workload-type guidance, and deployment notes by rollup type.
+
+<VideoWatch slug="decentralized-ai-ethereum-ethdenver" />
+
+## Frequently asked questions {#faq}
+
+<ExpandableCard title="Why would an AI agent use Ethereum instead of a centralized API?">
+
+Centralized APIs require accounts, API keys, rate limits set by the provider, and trust that the provider will not change terms, throttle access, or shut down. Ethereum provides a global, permissionless API that any agent can call without registration. The same DeFi protocols, payment infrastructure, and identity registries are accessible to any address (human or machine) without gatekeeping.
+
+</ExpandableCard>
+
+<ExpandableCard title="What does Ethereum provide for AI agents that other blockchains may not?">
+
+Three capabilities in combination: the deepest ecosystem of production smart contracts (most DeFi, most stablecoins, most tooling), the most mature smart account infrastructure (ERC-4337 with production EntryPoint deployments on all major networks, EIP-7702 live since May 2025), and a production-deployed onchain agent identity standard (ERC-8004, live January 29, 2026 — Draft status, in active adoption). Evaluate whether your agent requires all three before choosing a settlement layer.
+
+</ExpandableCard>
+
+## Further reading {#further-reading}
+
+- [The promise and challenges of crypto + AI applications](https://vitalik.eth.limo/general/2024/01/30/cryptoai.html) — Vitalik Buterin
+- [Autonomous agents on blockchains: standards, execution models, and trust boundaries](https://arxiv.org/abs/2601.04583) — arXiv
+- [5 Ways Blockchains Help AI Agents](https://a16zcrypto.com/posts/article/5-ways-blockchains-help-ai-agents/) — a16z
+- [Account abstraction (ERC-4337)](https://ethereum.org/en/roadmap/account-abstraction/) — ethereum.org
+- [EIP-7702: Smart account delegation for existing wallets](https://ethereum.org/en/roadmap/pectra/7702/) — ethereum.org
+- [ERC-8004: Trustless agent identity standard](https://eips.ethereum.org/EIPS/eip-8004) — Ethereum Improvement Proposals
+- [x402: Machine-to-machine payment protocol](https://docs.x402.org/)