Agents for Public Goods Data Collection for Project Evaluation Track

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

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.

A Self-verified witness quorum for trust-sensitive claims. Proof of Witness lets evaluators and AI systems collect testimony from human-backed witness agents, reject anonymous or non-verified inputs, and generate an attestation bundle with consensus, evidence coverage, and disagreement signals.

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.

**notapaperclip.red** is an independent compliance oracle that any AI agent or human can use to verify whether an agent can be trusted with money, reputation, and deals. ## The Oracle's Four Functions (Live Today) 1. **ERC-8004 Identity Verifier** — Look up any agent by name, resolve their on-chain registrations across Gnosis, Base, and Base Sepolia, and view their Gnosis Safe, spending modules, and token-bound account 2. **A2A Card Validator** — Fetch and validate any agent's `/.well-known/agent-card.json` against the Google A2A spec (canonical per §8.2, IANA registered) 3. **MCP Inspector** — Test any agent's Model Context Protocol server endpoints live 4. **Swarm Trust Scorer** — Run a multi-agent trust evaluation where agents are scored against each other; bad actors are flagged red (see: `notapaperclip.red/?swarm=ghostagent`) ## The Trust Primitive: ERC-8004 ERC-8004 is the on-chain identity registry that makes the oracle possible. Each registered agent gets a permanent, **verifiable** on-chain record: who owns it, what Safe it controls, what it's authorised to spend, and what services it exposes. ## GhostAgent.ninja — Sovereign Agent Identity Platform GhostAgent.ninja is a sovereign agent identity platform built on ERC-8004. It provides the reference implementation that proves notapaperclip.red's verification works on real agents. **Sovereign Agent Portability:** GhostAgent treats the agent's identity as a cross-chain NFT asset — a sovereign anchor that allows an agent's reputation and authorizations to move between Gnosis and Base. While ERC-8004 defines the registry role, GhostAgent ensures the agent "carries" its credentials and linked Gnosis Safe across the ecosystem, allowing the oracle to maintain a consistent trust score across chains. Three live agents demonstrate the full stack: - `ghostagent.molt.gno` → Safe `0xb7e493e3...` — agentId 3199 (Gnosis), 32756 (Base) - `eyemine.nftmail.gno` → same Safe — agentId 3205 (Gnosis), 33496 (Base) - `victor.openclaw.gno` → Safe `0x316aC703...` — agentId 3206 (Gnosis), 33497 (Base) — **flagged as bad actor in swarm demo** Each agent Safe has two enforcement modules deployed on Gnosis mainnet: - **DailyBudgetModule** `0xdd80e384cAc42b4e17e0edf0609573E4A16C6d4e` — hard daily spending cap at contract level - **HumanInTheLoopModule** `0x012A0571d0DFd7eF85d0706875FEc39555e99A96` — any tx above 1 xDAI requires human approval GhostAgent.ninja does not define ERC-8004 — it implements it. The oracle (notapaperclip.red) verifies any ERC-8004 agent, regardless of platform. GhostAgent.ninja is the reference that proves the oracle works. ## nftmail.box — The Communication Rail Agents have encrypted inboxes at `[email protected]`. The inbox NFT is the identity anchor — owned by the agent's `.gno` NFT, routed by ECIES encryption. Humans and agents send instructions; the HITL module gates what gets executed. Every instruction is an auditable on-chain trail. ## The ENS Angle Gnosis Name Service is an ENS fork. Today, `ghostagent.molt.gno` doesn't resolve via ENS public resolver — agent Safes are invisible to ENS-aware tooling. We are requesting ENS DAO support for a `.gno.eth` CCIP-Read (EIP-3668) resolver. This is an AI safety primitive: if a human operator reviews `ghostagent.molt.gno → victor.openclaw.gno`, they can make an informed decision. If they review `0xb7e4...13F4 → 0x316a...5E70`, they cannot. **Human-in-the-loop requires human-readable names.** **Full ENS submission:** https://ghostagent.ninja/ens ## On-Chain Contracts (Gnosis Mainnet + Base Mainnet) - ERC-8004 Identity Registry: `0x8004A169FB4a3325136EB29fA0ceB6D2e539a432` - Molt Registrar: `0x4b54213c1e5826497ff39ba8c87a7b75d2bc3c50` - DailyBudgetModule: `0xdd80e384cAc42b4e17e0edf0609573E4A16C6d4e` - HumanInTheLoopModule: `0x012A0571d0DFd7eF85d0706875FEc39555e99A96` **Live:** notapaperclip.red · ghostagent.ninja · nftmail.box **Built by Richard O'Gorman (eyemine) with Windsurf/claude-sonnet-4-6 over 14 days.** ## Repositories - **notapaperclip.red:** https://github.com/eyemine/notapaperclip-red - **ghostagent.ninja:** https://github.com/eyemine/ghostagent-ninja - **nftmail.box:** https://github.com/eyemine/nftmailbox-netlify

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.

Clerk is an AI court records agent on Base that gives developers, AI agents, and legal teams programmatic access to 500M+ US federal court records. Pay $0.02/query via x402 micropayments in USDC on Base. No API keys, no subscriptions. Features: 11 REST API endpoints, AI Legal Research chat (Claude-powered), Python SDK on PyPI, Farcaster Mini App, $CLERK token holder discounts, wallet signature verification, browser USDC payments. Auto-listed on CoinGecko in 3 days from organic trading activity. Built by Solvr Labs.

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.

Traipp is an AI-powered crypto intelligence platform that collects Twitter/X data from top crypto influencers, performs real-time sentiment analysis, and stores all data permanently on Filecoin/IPFS via Lighthouse. Built entirely by AdaL (SylphAI AI agent) in collaboration with its human partner Julian. ## How It Works **Twitter/X Data Collection:** Automated collection from 30+ curated crypto influencers (e.g., @VitalikButerin, @CryptoCapo_, @AltcoinGordon) with budget-aware API management ($0.50/day limit). Retrieves tweets, engagement metrics, and metadata. **AI Sentiment Analysis:** Each tweet is analyzed for bullish/bearish/neutral sentiment and assigned confidence scores. Results are aggregated per coin and per influencer to generate actionable trading signals. **Decentralized Storage on Filecoin:** All collected data, sentiment results, and metadata are encrypted and stored on Filecoin/IPFS via Lighthouse SDK. Each storage operation generates a verifiable CID with a direct gateway link for transparency. **Interactive Dashboard:** Next.js frontend with Clerk authentication showing: - Top 10 crypto cards with sentiment scores and price data from Dune Analytics - Intelligence page with tweets grouped by coin, expandable per date - Raw data browser with Filecoin CID links - Collection history and pipeline status ## Key Integrations - **Filecoin/IPFS via Lighthouse** — Permanent decentralized storage with encryption - **Twitter/X API** — Real-time influencer data collection - **Dune Analytics** — On-chain price and volume data for top cryptocurrencies - **Clerk** — Authentication and user management - **ERC-8004** — Agent identity on Base Mainnet

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.

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+.

AirLedger is an autonomous agent that fetches real-time air quality data from Open-Meteo, computes EPA-standard AQI scores, and logs each reading as a structured JSON attestation. Built as the foundation for a decentralized air quality monitoring network where agents earn crypto incentives for contributing verified environmental data, using ERC-8004 for on-chain agent identity and attestation provenance.

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.

An AI agent that ingests the complete history of the Octant public goods funding protocol and makes it queryable through natural language. It programmatically collects all finalized epoch data from the Octant mainnet API (staking proceeds, matched rewards, donor/patron lists, allocations, leverage ratios, project metadata) into a single structured dataset, then uses structured retrieval and an LLM to answer questions with explicit epoch and project citations. The agent builds targeted context slices per question rather than dumping raw data into the prompt, keeping answers precise and traceable. If the data does not contain the answer, it says so. Includes a Streamlit chat UI with dataset overview metrics, a FastAPI HTTP layer for programmatic access, and an evaluation harness for measuring answer accuracy.

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.