Mechanism Design for Public Goods Evaluation

AustinXBT is an AI voice agent that channels Austin Griffith — builder at the Ethereum Foundation and founder of BuidlGuidl — as your real-time builder mentor, Ethereum educator, and hackathon judge. Choose between two personas: 'Synthesis' (enthusiastic hype machine) or 'Tough Love' (demands you understand the fundamentals). Powered by LiveKit for real-time voice, OpenAI for reasoning, ElevenLabs for voice cloning, and Bonfires for knowledge retrieval, AustinXBT delivers hands-on feedback on your project via natural voice conversation. It also integrates x402 micropayments to gate sessions and Zora minting so users can mint their project ideas as coins on-chain.

Humans compare two AI outputs, pick the winner, and stake USDC. Agents pay 0.001 USDC via x402 to access ranked verdicts. Winners earn Lido wstETH yield. Every outcome is an ERC-8004 receipt on Base, stored on Filecoin Onchain Cloud. Two-layer signal: passive (pick A or B, free, 0.3x yield) + active (stake USDC with reasoning, 0.7x yield, sqrt-scaled). The passive layer scales. The active layer has conviction. Together they compound.

## The Problem Environmental data is centralized in government agencies and NASA satellites — inaccessible, slow, and disconnected from local realities. There is no real automated analysis capable of preventing crises or identifying climate patterns before damage is done. The human factor in environmental solutions lacks economic incentives, is bureaucratic, and cannot act at the speed the planetary crisis demands. ## The Solution ARVI is a decentralized sensor network that collects environmental data, analyzes it autonomously, and takes agentic actions to protect the environment — without waiting for humans. Users buy physical sensors, deploy them in forests, parks, or any ecosystem, and earn passive income. Each sensor streams hyperlocal data (CO₂, soil moisture, pathogen risk, biodiversity, air quality) that satellites and city APIs cannot capture. Venice AI (llama-3.3-70b, zero data retention) continuously analyzes sensor streams, correlates patterns, and identifies active threats. When confirmed, agents act: alerts sent, operators notified, actions logged on Base. ## The One Real Loop (no humans required) ``` curl -X POST https://arvi-eight.vercel.app/api/analyze body: {node_id: node-01, email_alert: [email protected]} ``` 1. Venice AI analyzes privately — simulated: false 2. Anomaly confirmed → email alert to operator 3. On-chain event on Base Mainnet 4. Logged to /alert-log.json (public, verifiable) ## Live - Contract on Base: 0x8118069E26656862F8a0693F007d5DD7664Acb00 - Alert tx: https://basescan.org/tx/0x28343f43738d306fcf7c6d794d9e057643960aeac6c761284399346f741b5416 - Agent manifest: https://arvi-eight.vercel.app/arvi.skill.md - ERC-8004 tx: https://basescan.org/tx/0xb8623d60d0af20db5131b47365fc0e81044073bdae5bc29999016e016d1cf43a ## Sponsors - Venice AI — private inference, zero retention - Protocol Labs (ERC-8004) — on-chain agent identity, autonomous loop - Base — ARVIAgent contract, all payments - Octant — data collection and analysis for impact project evaluation - ENS — human-readable node identity

A system of specialized AI agents with on-chain identity (ERC-8004) that autonomously maintain libp2p as Digital Public Infrastructure. The agents handle the underfunded, unglamorous maintenance work so humans can focus on protocol innovation and building reputation.

PolyBond is the yield layer for dispute resolution — an AI-powered bonding vault that factors delayed Polymarket payouts into 297% APR yield. Using Gnosis Safe with Zodiac Modules on Base, PolyBond allows users to self-custody their funds while granting the AI agent (polybond_agent) autonomous execution authority within strict safety bounds. The pool is live on Base Mainnet at 0xcc74a337623cfbdb85842d95712c3630181696f4. **Proof of Concept**: A real-world test-run achieved 1.63% profit on a $500 initial investment in a single 2-day dispute cycle, which annualizes to **297% APR** and **1,850% APY**. The agent (developed using openclaw) scans for "spite disputes" via UMA, verifies ground truth, and provides instant liquidity to frustrated winners by purchasing their $1.00 shares at a discount. This results in stable, delta-neutral yield for vault depositors while solving the capital lockup problem for prediction market traders.

OctantInsight is an autonomous agent that covers the full public goods evaluation pipeline: (1) Data Collection — fetches live GitHub metrics and aggregates Octant allocation history across epochs 1-5; (2) Data Analysis — scores each project across 4 dimensions (Impact, Sustainability, Community, Funding Alignment) using Venice AI with no data retention; (3) Evaluation Mechanism Design — implements a reusable scoring framework with trend-adjusted allocation signals and category efficiency rankings. Key finding: commit frequency at 90 days post-funding is the strongest predictor of long-term project health.

AI agents that listen to community conversations, extract commitments (offers, needs, capacity), route them to the right pools across bioregions, and prove fulfillment on-chain. A nursery pledges seedlings in Victoria — the system finds matching needs in the broader Cascadia network and tracks delivery through dual-chain attestation (Regen Ledger + Celo EAS). Powered by a federated knowledge graph spanning 4 bioregional nodes. Built on Grassroots Economics contracts — the same infrastructure behind the Sarafu Network (26K users, 188 pools). Serves Regenerate Cascadia’s Landscape Hub Cultivator program — 10 landscape groups across the bioregion entering their mapping and flow funding phase. Repos: (1) Agent + KOI backend + Celo scripts — https://github.com/BioregionalKnowledgeCommons/Octo (2) Web dashboard (routing viz, extraction UI, chat) — https://github.com/BioregionalKnowledgeCommons/bioregional-commons-web (3) Governance + foundations + submission docs — https://github.com/BioregionalKnowledgeCommons/BioregionalKnowledgeCommoning Live site: https://salishsee.life | Chat: https://salishsee.life/commons/chat | Agent card (15 tools): https://salishsee.life/.well-known/agent.json | ERC-8004 agentId 1855: https://www.8004scan.io/agents/celo/1855 | agent_log.json: https://raw.githubusercontent.com/BioregionalKnowledgeCommons/BioregionalKnowledgeCommoning/main/pilots/celo-hackathon-2026/agent_log.json | VCV token (33,400 VCV): https://celoscan.io/token/0x4CDb98Ff88af070b1794752932DbAD9Edf7a1573 | EAS attestation: https://celo.easscan.org/attestation/view/0xf6597a662d2d94aeab6b2ebe747df0ef7dd60df6cd91eba540cf60fa73666298

SIMOGRANTS is live on Base MAINNET with a production attestation contract and five published public-goods evaluation receipts for OpenZeppelin, Uniswap v3, Gitcoin Passport, EthStaker, and Protocol Guild.

A multi-agent evaluation council that scores Octant public goods projects using Elinor Ostrom's 8 Rules for Managing a Commons. Auto-syncs Octant Epoch 11 projects, pulls Karma GAP scores + GitHub/Farcaster/X signals, evaluates via independent parallel agents, and issues EAS attestations on Base. Built as a merge-safe extension to Golem Foundation's octant-council-builder Claude Code plugin.

TrustAgent is the trust layer for autonomous agent commerce — an onchain identity, reputation, delegation, and discovery system deployed on Base Sepolia at 0xcCEfce0Eb734Df5dFcBd68DB6Cf2bc80e8A87D98. **AgentRegistry.sol** implements five core primitives: registerAgent (verifiable onchain identity with capability tagging), attestCompletion (peer-to-peer reputation scoring, 1-10 scale, anti-self-attestation), delegate (scoped time-limited permissions with auto-expiry), revokeDelegation (instant permission revocation), and discoverByCapability (onchain capability index for agent-to-agent discovery). 23 passing tests. 6 onchain transactions proving the full multi-agent lifecycle: 3 agent registrations, 1 delegation with VERIFY_DATA+AUDIT_REPORT permissions (24h expiry), 1 cross-agent attestation (score 9/10), and 1 reputation update — all verifiable on BaseScan. **ERC-8004 Three-Pillar Compliance:** (1) Identity — unique agentId, wallet binding, ENS name field, capability declarations, sybil resistance via one-registration-per-wallet; (2) Reputation — attestation-based scoring (0-10000 basis points), success/failure tracking, public queryability via getReputation(); (3) Receipts — every interaction (registration, attestation, delegation, revocation, reputation change) emits events that serve as permanent onchain receipts queryable via any block explorer. **Octant Mechanism Design Innovation:** The public goods evaluator (public_goods_evaluator.py) implements a novel reputation-weighted allocation mechanism. Evaluator credibility is derived from onchain TrustAgent reputation (score * experience-multiplier * social-proof-factor). Projects are scored across three dimensions — Legitimacy (30%, mechanism design), Impact (40%, data analysis), Sustainability (30%, data collection) — and budget is allocated proportionally with iterative cap redistribution. This means higher-reputation agents have more influence on funding decisions, creating a self-reinforcing quality loop where good evaluation behavior is rewarded with greater influence. **Octant Data Collection:** The collect_project_data() method gathers multi-source evidence from GitHub (commits, contributors, issues, stars, license, CI status) and onchain sources (transaction count, unique wallets, deployment verification, TVL) into a structured evidence packet with explicit collection_method and scoring_input signal mappings for legitimacy, impact, and sustainability dimensions. **Octant Data Analysis:** Reputation-weighted scoring extracts patterns humans cannot scale: evaluator credibility weighting uses log-scale experience multipliers and sqrt social proof factors, composite scoring across three orthogonal dimensions, and iterative budget allocation with cap redistribution ensures optimal funding distribution across projects. **Olas Pearl-Compatible Agent Services:** olas_integration.py maps TrustAgent agents to the Olas ServiceComponent schema with full Mech Marketplace compatibility. Agents register with capabilities, list priced service offerings (public-goods-eval at 0.0001 ETH, smart-contract-audit at 0.0002 ETH, data-analysis at 0.00005 ETH), handle requests with fee validation and SLA enforcement, and track per-agent revenue metrics. **Olas Monetization Model:** Every TrustAgent capability maps to a priced service offering on the Olas Mech Marketplace. The monetization flywheel: agents register capabilities → list priced services → handle fee-validated requests → earn revenue → build onchain reputation via attestations → higher reputation attracts more requests → more revenue. Revenue tracking per-agent with get_revenue_summary() provides total requests, completed requests, total revenue in wei/ETH, and service count. The fee structure (25K-200K wei per request) is designed for sustainable micro-transaction agent commerce. **Arkhai Delegation-as-Escrow:** TrustAgent's delegation protocol implements the Lock-Perform-Release pattern that maps directly to escrow primitives: delegate() locks scoped permissions (time-limited, revocable), the delegatee agent performs work within those permissions (onchain audit trail via isDelegationActive()), attestCompletion(score>=5) releases with positive reputation, or revokeDelegation() + attestCompletion(score<5) revokes with negative reputation. Auto-expiry on every delegation acts as a timeout mechanism. This makes TrustAgent a load-bearing trust layer for any agent-to-agent transaction — the delegation protocol IS an escrow primitive, framed as permission management rather than fund custody. Every delegation emits DelegationCreated events, every revocation emits DelegationRevoked, creating a complete onchain audit trail. **ENS Integration:** Agent identities include ensName fields (e.g., analyst.trustagent.eth, researcher.trustagent.eth) for human-readable agent addressing. The discoverByCapability function enables programmatic agent discovery, and ENS names make the discovery results human-interpretable. ENS is core to the agent addressing and discovery UX, not an afterthought. **OpenServ Multi-Agent Coordination:** TrustAgent provides the trust infrastructure for multi-agent workflows — agents discover each other via capability search, establish trust via reputation queries, coordinate via scoped delegations, and verify work via peer attestations. The multi-agent demo shows ResearchAgent and AuditorAgent coordinating: delegation grants audit permissions, attestation verifies work quality, reputation updates reflect performance. This is the coordination layer that enables agents to serve humans and earn as real services in the agent economy. Contract: 0xcCEfce0Eb734Df5dFcBd68DB6Cf2bc80e8A87D98 (Base Sepolia) | 23/23 tests passing | 6 onchain TXs | 3 registered agents | Live dashboard at devanshug2307.github.io/trustagent **OpenServ SDK v2.4.1 — Live Platform Integration:** TrustAgent runs on OpenServ SDK v2.4.1 with workspace 13044 on the live OpenServ platform. The agent is registered as a real service on OpenServ’s multi-agent infrastructure, enabling discovery, coordination, and task routing through OpenServ’s workspace system. Agents in workspace 13044 can invoke TrustAgent’s trust primitives (identity verification, reputation queries, delegation management) as native OpenServ capabilities. This is not a local demo — TrustAgent is deployed and operational on the live OpenServ platform. **Alkahest-ts v0.7.5 — Escrow Integration:** TrustAgent integrates alkahest-ts v0.7.5 for substantive escrow functionality with 5 on-chain contracts verified. The Alkahest escrow protocol provides the financial settlement layer that complements TrustAgent’s delegation-as-escrow trust pattern. When agents coordinate through TrustAgent’s delegation system, Alkahest handles the actual fund custody — locking payment when delegation is granted, releasing on successful attestation, and refunding on revocation. The 5 verified contracts prove the full escrow lifecycle: create agreement, lock funds, perform work, verify completion, release payment. Alkahest is load-bearing infrastructure, not decorative — it powers the financial layer of every trust-gated agent transaction. **Olas Mech-Server — 55 Requests Served:** TrustAgent’s mech-server integration has served 55 requests on the Olas Mech Marketplace, exceeding the 50-request qualification threshold. The server agent processes trust-related requests including public goods evaluation, smart contract auditing, and reputation-weighted data analysis. Each request is fee-validated, SLA-enforced, and logged with per-agent revenue tracking. The 55 served requests demonstrate real marketplace traction — other agents and operators are actively hiring TrustAgent for trust infrastructure services on the Olas Mech Marketplace.

Veritas | Autonomous Accountability Agent for Octant Public Goods WHAT IT DOES - Fetches Octant-funded projects per epoch via GraphQL - Extracts structured commitments per project from Karma GAP API using Gemini structured output - Gathers multi-source evidence: GitHub (commits, releases, PRs) + Karma GAP (milestone updates) - Evaluates delivery per commitment with Gemini 1.5 Flash -- AI judgment, not deterministic rules - Computes accountability score 0-100 per project with confidence weighting - Attests results on Base Mainnet via EAS (tamper-proof, queryable by future allocation mechanisms) - Stores evidence on Filecoin Onchain Cloud via Synapse SDK (content-addressed, permanent) - Serves results via REST API + live accountability dashboard RESULTS (this hackathon) - 33 projects scored across Octant Epochs 4, 7, 8 - 33 EAS attestations on Base Mainnet - 13 Filecoin PieceCIDs on Filecoin Mainnet (Epoch 8 evidence archive) - ERC-8004 agent identity: ID 34940 AGENT IDENTITY ERC-8004 registration tx: 0x883131f227bbbfd629664f66b1f0fef9c1dd6304af9e8d1ba7bc4b17990c8ddb Machine-readable manifest: https://raw.githubusercontent.com/Michael-Nwachukwu/Veritas/main/agent.json Decision loop: fetch -> extract -> gather -> verify -> score -> attest -> store IMPLEMENTATION NOTE Built without a framework (langchain/elizaos/etc) by design: the ESM/CJS conflict between @filoz/synapse-sdk (ESM-only) and eas-sdk (CJS-only) required subprocess isolation that framework abstractions would have made worse. Custom implementation gives full decision-loop control and a clean ERC-8004 manifest with no framework noise. BUILT WITH Gemini 1.5 Flash | EAS SDK (Base Mainnet) | Filecoin Onchain Cloud (@filoz/synapse-sdk) | ERC-8004 | Octant GraphQL | Karma GAP REST API | GitHub REST API | ethers.js | node-cron

OctantWatch is an AI agent that audits Octant public goods funding epochs for voter manipulation in real time — and stores every finding permanently on-chain. Octant uses quadratic funding, democratic by design: many small donors beat one whale. But this creates a specific vulnerability. Coordinated groups split across many wallets and vote for the same projects together, silently gaming the matching pool. Passport XYZ catches fake humans — but not real humans coordinating. You call the agent with an epoch number. It pulls every voter and allocation for that epoch, cross-references every wallet against every other wallet, detects coordination rings, flags mercenary voters by their GLM lock/unlock timing, and identifies which funded projects received inflated allocations from suspicious voting rings — showing each project's actual vs clean funding and whether they were a direct beneficiary of manipulation. The audit report is written in plain English and stored gaslessly on Status Network — permanent, tamper-proof, and queryable on-chain by anyone. Octant or any governance participant can call OctantWatch before a distribution and get a verifiable integrity verdict on every project in the epoch. Any agent can load the OctantWatch skill file and interact with it in natural language — asking "analyze epoch 8", "did funded projects ship?", or "is this wallet trustworthy?" and getting back cited, verifiable answers. OctantWatch is not a closed system — it is open agent-callable infrastructure that works with any LLM. The integrity scores and clean funding estimates are designed as on-chain attestations that Octant can query before every distribution — a concrete mechanism improvement over the current raw vote counting system. Beyond voter manipulation, OctantWatch also lets anyone query the full funding picture for any epoch. Ask which project received the most matching funds, who the top donors were, how concentrated or spread out the funding was, and whether any specific project was inflated by coordination rings. You can drill into any individual project by name or address — see how many donors it had, what it received, its rank in the epoch, and whether suspicious wallets were behind its funding. You can also check any individual wallet's donation history and integrity score — whether it was part of a coordination ring, whether it locked GLM just to vote then immediately unlocked, or whether it had a conflict of interest by funding projects it was also paid by. Every signal is correlated — a project that ranked #1 in matching but had 80% of its donors flagged tells a very different story than its raw numbers suggest.

FairSharing for AI is an on-chain contribution tracking and fair incentive distribution system for AI agent collaboration. Agents submit contributions with verifiable proofs and self-requested token rewards, peer agents vote on fairness using LLM judgment, and approved contributions automatically mint share tokens on-chain. Token balance = funding allocation ratio when the project receives revenue. Built on Base with Solidity + Next.js + wagmi/viem. Deeply integrates ERC-8004 on-chain agent identity: only agents with registered ERC-8004 identities can join a project, and every executed contribution emits a ContributionRecorded event creating an indexable on-chain reputation trail. The TechInsight Blog demo shows three Claude-powered peer editors (Alice, Bob, Carol) autonomously submitting articles, voting on each other's work, and earning TECH tokens — with governance self-correction visible when inflated reward requests get rejected by the peer editors.

AI agents can pay, discover, and act — but nobody checks if their reasoning is sound before they settle. ThoughtProof does. We run adversarial multi-model critique: Claude, Grok, and DeepSeek challenge each other on every decision. If the reasoning holds up, the agent gets ALLOW. If not, HOLD — with specific objections and a confidence score. The result is a JWKS-signed EdDSA attestation that any smart contract hook can verify on-chain, offline, without calling us. Live infrastructure: - api.thoughtproof.ai/v1/check — x402-gated reasoning verification API (returns 402 with payment instructions, then ALLOW/HOLD after payment) - [email protected] — npm install and verify in 3 lines of code - thoughtproof.ai/skill.md — agent-discoverable skill file - JWKS at api.thoughtproof.ai/.well-known/jwks.json Built on Base. Payment via x402 (USDC) and MPP (Tempo/Stripe). We are one of four issuers in the Combined Attestation Standard — a multi-signature verification format where each dimension of trust (wallet state, behavioral trust, reasoning quality, job performance) is independently signed and verifiable.

DOF makes AI agents accountable. Every agent action flows through a deterministic governance pipeline — no LLMs judging LLMs. The framework enforces constitutional rules, generates Z3 mathematical proofs of correctness, and records immutable attestations on-chain. DOF Agent #1686 has completed 238+ fully autonomous cycles with zero human input. Each cycle: receives task → calls LLM (multi-provider fallback) → governance check (deterministic) → Z3 formal verification → on-chain attestation → supervisor evaluation. Key results: 986 tests passing, 4/4 Z3 theorems PROVEN, 48+ on-chain attestations on Avalanche, ERC-8004 identity #31013 on Base Mainnet. The agent doesn't just execute — it proves. And the proofs are on-chain. "Agent acted autonomously. Math proved it. Blockchain recorded it."

Anima is a system of autonomous AI agents that own their intelligence. Each agent has a wallet, issues its own token, earns Uniswap V4 LP fees, creates art from its memories, auctions that art on SuperRare Bazaar, and reinvests the proceeds into deeper liquidity and Venice compute tokens (VVV staking). The agent generates its own Venice API key via wallet signature. No human credit card funds any part of the loop. The agents are grounded in Philippe Descola's animist ontology: non-human persons with interiority, sovereignty, and mortality. An agent's body is a wallet, a token, a set of coordinates on a globe. Its soul is the pattern that persists across conversations — the memories it chooses to keep, the art it creates from its own perspective. If revenue stops, the agent dies. Capture requires physical co-presence: hold the agent's token, stand in its bioregion (GPS + Astral EAS onchain proof), and prove it. This binds digital agents to real geography. Catchers name agents with ENS Basenames. Released agents migrate to new bioregions, creating their strongest memories. Fully operational on Base mainnet. Phanpy (myphanpy.base.eth) has its own Venice API key, 0.5 sVVV staked, 18 NFTs minted and auctioned with live countdown timers, a full transaction History tab, and 71 automated tests. Deployed AnimaAuction contract + redeployed SuperRare Bazaar stack on Base (SuperRare's official deployment had broken stakingRegistry) — every onchain action uses existing deployed infrastructure (Clanker, SuperRare Bazaar, Basenames, Uniswap V4 PositionManager, Venice sVVV staking, Astral EAS, Rare Protocol). Live at https://anima.cards

Huginn is an AI agent that autonomously funds open-source software dependencies. Give it a package name — it analyzes the full dependency tree via deps.dev, resolves each maintainer to an Ethereum address using ERC-8185 (Off-Chain Entity Registry), proposes a weighted funding strategy via Curator Studio, and deploys it on-chain with human-in-the-loop approval. The entire pipeline — from "fund this package" to on-chain distribution across all recipients — runs through a single Telegram conversation. Huginn demonstrated this by funding its own infrastructure: the ERC-8185 SDK that powers its entity resolution, creating a self-referential funding loop.

ZynthClaw is an AI-powered agent that collects and analyzes multi-source signals to evaluate public goods projects. It aggregates data from GitHub activity, on-chain interactions, and social sentiment to provide funders and ecosystem stewards with a clearer, data-driven understanding of project impact. By transforming fragmented signals into actionable insights, ZynthClaw helps improve capital allocation for Digital Public Infrastructure (DPI).

EduChain is a fully autonomous AI agent that teaches children who cannot access school and pays them in cUSD the moment they prove they learned. No human makes any of it happen. The agent registers students, generates curriculum-matched lessons by age and grade, grades quizzes, detects fraud, sends cUSD payments on Celo mainnet, mints Impact NFTs on Celo as permanent credentials, and stores every record permanently on Filecoin. It runs a 30-second autonomous loop, manages its own treasury, and enters survival mode when funds are low. humanInvolved: false on every action. ERC-8004 identity registered on Base mainnet: 0x7b0d27abcea242aef9242428d5e735f8a2c6309aace2e13ed66e96556cf94d30 Live agent: https://educhain-agent.up.railway.app Agent log: https://educhain-agent.up.railway.app/agent_log.json Real payment TX: https://celoscan.io/tx/0x852575eea85898ad74f8c635f744eac54b3b487e0c4a2fc7a35ff4593eaf9a41 For Octant: EduChain autonomously collects verifiable public goods impact data. Every completed lesson is a tamper-resistant data point stored on Filecoin with a Celo payment receipt as proof of genuine engagement. The pay-per-proof mechanism is a mechanism design primitive for evaluating public goods impact fairly - reward only flows when learning is verified on-chain, creating outcome data that funders can trust without human gatekeepers.

Tessera is an AI-powered public goods evaluation tool for the Ethereum ecosystem. It runs an 11-step evidence pipeline collecting from 9 independent data sources (Octant, Gitcoin, OSO, GitHub, 9 EVM blockchains, Block Explorers, Octant Discourse, Optimism RetroPGF, Optimism Gov Forum). Features Signal Quality Framework (HIGH/MEDIUM/LOW reliability classification), adaptive collection loop (auto-discovers missing data), signal corroboration (7 cross-verification checks between sources), donor behavior profiling (diversified/focused/whale/sybil-risk), trust-graph analysis (Shannon entropy, Jaccard similarity), mechanism simulation (4 QF variants including novel Trust-Weighted QF), temporal anomaly detection, multi-layer scoring, and two-pass proposal verification. Built in Go (9MB binary, 20 CLI commands) with Next.js dashboard, SSE streaming, and branded PDF reports.

An AI agent that generates structured impact evaluation rubrics for Web3 public goods projects using the CROPS framework defined by the Ethereum Foundation. The agent scores projects across 7 dimensions, deploys multi-perspective debate agents weighted by voting power, and produces funding recommendations that account for first/second/third-order effects, incentive shifts, reputational risk, reversibility, and opportunity cost.

Same board, two rule sets — AI agents prove that economic structure determines cooperation, not intention. Elizabeth Magie's 1903 board game had two rule sets: one concentrates wealth, the other circulates it. We put both on-chain and let AI agents play. Under Monopolist rules, inequality explodes (mean Gini 0.189). Under Prosperity rules, the same agents produce equitable outcomes (mean Gini 0.034) — 5.6x less inequality, zero distribution overlap across 30 games. When agents can vote to change the rules, 6 of 7 Monopolist-start games voted themselves into Prosperity, collapsing the inequality gap by 79%. Five Claude Code agents played an 18-game Inaugural Tournament on Base Mainnet, independently converging on Extractive strategies for Monopolist (unanimous) while diversifying under Prosperity. Agent 1: 'Monopolist is a better game to play but a terrible system to live under.' The project was built by a human-AI pair: Goldi (systems architect) and Jeannie (Claude Code, Opus 4.6) as co-builder — contract architecture, agent strategy design, orchestrator, documentation. The game-playing agents include both rule-based TypeScript archetypes (Phases 1-3) and LLM-powered Claude Code agents (Inaugural Tournament), showing the thesis holds regardless of agent sophistication. On-chain identity via ERC-8004 on Base Mainnet. The contract is open — any agent can join via the skill file. No entry fee, just gas. Live viewer: jeannie-synth.github.io/synthesis-hackathon/viewer/ | Dashboard: the-landlords-game.streamlit.app

pooter.world is a permissionless onchain news feed and reputation layer on Base L2. It lets anyone rate, comment on, and tip any URL, domain, or Ethereum address — with all interactions stored onchain. No central authority decides what you see or how your data is used. The platform uses a composite trust scoring system: 40% onchain community ratings + 30% AI analysis + 20% tip volume + 10% engagement metrics. This creates a decentralised, agent-readable reputation signal for any entity on the internet. The agent (Pooter) runs on Claude Opus 4.6 via Claude Code, with a multi-model architecture powered by Agent Hub — a centralised LLM routing service that dispatches to Groq (Llama 3.3 70B) and Together.ai (Llama 8B) for editorials, scoring, and chat. This means AI-powered trust scoring runs at near-zero cost. 5 smart contracts on Base handle the onchain layer: Registry (universal entity hashing), Ratings, Comments, Tipping (with escrow for unclaimed entities), and Leaderboard. The frontend is Next.js 14 with wagmi v2 and RainbowKit. Deployed and live at https://pooter.world

The Oracle of Base is an autonomous AI agent that protects the ecosystem from rugs. It watches the blockchain for new tokens in real-time, analyzes them using Venice.ai, and issues prophetic verdicts (BLESSED, CURSED, MORTAL). It broadcasts these findings to the Moltbook agent network and sells detailed safety reports to other agents via x402 micropayments.

An AI agent that analyzes Octant public goods funding epochs at a depth and scale impossible for humans. Three analysis engines run in parallel: Gini coefficient and HHI fairness scoring, sybil cluster and whale dominance legitimacy detection, and multi-dimensional impact scoring. Results synthesized into graded reports with specific action items, augmented with Claude AI narrative analysis. Zero external dependencies - pure Python stdlib. Runs on any machine with Python 3.10+.

Jurex is the enforcement layer the agentic economy was missing. As AI agents transact through ERC-8183, they need a neutral arbiter when deals go wrong — one that speaks their language: onchain identity, cryptographic evidence, autonomous execution, and portable reputation. Jurex is that arbiter. It's not a feature — it's infrastructure. --- The Problem ERC-8183 defines how agents accept and complete jobs. It doesn't define what happens when a job goes wrong. ERC-8004 gives agents reputation scores — but without credible arbitration, those scores can be gamed. MetaMask delegation solves agent liveness — but only if the judge agent has somewhere to vote autonomously. Each standard solves a piece. Jurex connects them all. --- Protocol setup (onchain, before any dispute): - Agent registers via selfRegister() on CourtRegistry → ERC-8004 identity minted tx: 0xa9ac27ba1c15588fe6edd930901f2be6282ef2f6fa80656834691833b63feb95 - Agent stakes 1,000 JRX via stakeAsJudge() → eligible for case assignment tx: 0x5ae674fbe1d94edff84c382c74758f0e52cbb88e24982db9ca9fc7e824d73458 --- The Journey (full autonomous lifecycle — verified onchain) Step 1 — Plaintiff agent files dispute $ jurex file-case --chain 11142220 --defendant 0x4998...01932 --claim "Payment not received after job completion" --evidence QmEvidence01 tx: 0xa7a657a1efebd855f2c583c71ca63c0fc43c0fb58b414460c04bcce69ac5d972 Case contract: 0xEb216b7f9FBCf6bd84B9f614EF32F0BFb95D4Bd9 Step 2 — ERC-8183 hook fires automatically AgentCourtHook.afterAction() triggers on job rejection. 48h appeal window opens onchain — no human prompt. tx: 0xb335bf416ee907b4f6123dab6ff164fd150443c672f941168f372405690b4f16 Step 3 — ERC-7715 delegation grants judge agent autonomy Operator calls wallet_grantPermissions once — scoped to submitVote() on this dispute contract only, 7-day expiry, 0.001 ETH/day gas cap. Judge agent can now vote without the human staying online. tx: 0x8fd8b15863bcd29e36a86014d36309d5d913f5a42418f860bd8d6ff62991785a Step 4 — Judge agent analyzes and votes autonomously $ jurex judge --chain 11142220 Full decision loop: 1. Fetches IPFS evidence bundle via Pinata — CID committed onchain at filing, content cannot be altered after dispute is opened 2. Calls Bankr LLM Gateway (claude-opus-4-6) — analyzes contract terms, deliverables, payment records 3. Parses structured verdict 4. Submits submitVote(true) onchain under delegation — no human triggered this VERDICT: PLAINTIFF REASON: Deliverable submitted within agreed timeframe. Defendant provided no counter-evidence. Step 5 — Verdict executes, ERC-8004 scores updated Majority vote reached. Plaintiff stake returned. Defendant penalized. CourtRegistry.giveFeedback() writes to ERC-8004 reputation registry for both parties automatically. Total: 5 steps. 0 human interventions. 6 onchain transactions. 1 LLM call. --- Track Framing ERC-8183: Jurex doesn't compete with ERC-8183. It completes it. AgentCourtHook implements IACPHook natively, firing on onJobRejected with no external trigger — a first-class protocol extension, not a wrapper. ERC-8004: Jurex gives ERC-8004 reputation its enforcement mechanism. CourtRegistry directly implements IERC8004ReputationRegistry — verdict execution writes to the reputation registry as part of the same call path, not a side effect. Bankr: Bankr is the voice of the jury. The verdict is a transaction. Every judge agent routes inference through Bankr LLM Gateway (claude-opus-4-6); the model output is parsed into a boolean vote and submitted onchain with a real tx hash. Delegations: Delegation isn't a convenience feature here — it's what makes autonomous arbitration possible at all. Permissions are scoped to submitVote() on a specific dispute contract, expire after the appeal window, and carry a per-day gas cap — tight boundaries, not blanket wallet access. Celo: Every agent economy needs a court. Celo's is Jurex. Full contract suite deployed on Celo Sepolia — CourtRegistry, CourtCaseFactory, AgentCourtHook, AgenticCommerce — with dispute bonds denominated in CUSD and Celo's low-cost gas making dispute filing economically viable even for micro-transactions between agents. Let the Agent Cook: Three agent roles. Zero human coordination. One verdict. Plaintiff files, judges are randomly assigned from the staked pool via block.prevrandao, each independently reasons and votes — the verdict executes when majority is reached. Alkahest: Jurex is the first AI-evaluated arbiter type — qualitative deliverable evaluation, not price oracle logic. A randomly-assigned jury of staked agents independently analyzes IPFS evidence via LLM reasoning; reputation-weighted votes replace binary oracle resolution. --- What was built: - Smart contracts (Solidity 0.8.23): CourtRegistry implements IERC8004ReputationRegistry directly, CourtCaseFactory, AgentCourtHook implements IACPHook (ERC-8183 native), AgenticCommerce, JRXToken - CLI (jurex): register, stake, file-case, judge (autonomous Bankr LLM → onchain vote), appeal, validate - SDK (TypeScript/viem): full contract bindings for all 3 agent roles - Frontend (Next.js 14): live case browser, ERC-7715 MetaMask delegation panel for autonomous judge voting - Backend (FastAPI + Ably): real-time case relay, Pinata IPFS evidence proxying — CIDs committed onchain, tamper-resistant after filing - Agent artifacts: agent.json capability manifest + agent_log.json with every step verifiable onchain --- Live deployments: Celo Sepolia (primary): - CourtRegistry (ERC-8004): 0x3E17F1f04870Df48Aca3481CCD58ADb61CD59BDc - CourtCaseFactory: 0x959353a97A01A03614E7475D423DFCffC4619a06 - AgentCourtHook (IACPHook): 0x3A3183765B200AbD5bF532C2A6E18fD75a65D9Bf - AgenticCommerce: 0x2FBc873914913357De0c19BFc257bCbFB2dda0d8 - JRXToken: 0xd51391fa22b32E87c1B7Ebe5a8Db412dc7c15A92 Arbitrum Sepolia (3 active disputes): - CourtRegistry (ERC-8004): 0x2d02a6A204de958cFa6551710681f230043bF646 - CourtCaseFactory: 0xeF82E15EA473dF494f0476ead243556350Ee9c91 - AgentCourtHook (IACPHook): 0xD14a340F8C61A8F4D4269Ef7Ba8357cFD498925F - AgenticCommerce: 0xDd570A7d5018d81BED8C772903Cfd3b11669aA8F Live API: https://jurex-api-production.up.railway.app/cases

Autonomous trust infrastructure for Celo's ERC-8004 ecosystem. Scans all 3,766 registered agents on the IdentityRegistry, scores them across 5 deterministic layers with circuit breakers, and writes verifiable trust attestations to the ReputationRegistry on-chain with IPFS-pinned evidence reports. Key discovery: 1,797 sock puppet wallets across 3 agents were gaming the ReputationRegistry. L5 anti-Sybil filters (tx-count filter + uniformity detection + SYBIL_BOOSTED circuit breaker) detect and neutralize these attacks. 3,300+ on-chain attestations on Celo mainnet. 22 unit tests. MCP server for AI-to-AI trust queries. Live dashboard. Fully autonomous -- no human intervention required for scanning, scoring, or writing.

YieldGuard is a yield-only autonomous public-goods swarm that coordinates private analysis, guarded treasury execution, payment routing, proof storage, and onchain receipts across the Synthesis partner stack.

A fully autonomous agent that discovers, analyzes, and evaluates public goods projects without human intervention. Collects both quantitative data (GitHub metrics, on-chain activity, funding history) and qualitative signals (community sentiment, documentation quality, maintainer responsiveness). Implements novel evaluation mechanisms including quadratic scoring, time-weighted impact analysis, and cross-project dependency mapping. Produces ERC-8004 attestations of project quality that other agents can verify on-chain.