Best Use of EigenCompute

A TEE-secured cryptocurrency price oracle running on EigenCompute that fetches prices from 3 independent APIs (CoinGecko, DeFiLlama, DexScreener), computes outlier-resistant medians, and publishes verifiable EAS attestations on Base. The TEE is structurally necessary, not bolted on — without it, the oracle is just another centralized price feed. EigenCompute Intel TDX enclave cryptographically proves the exact Docker image that ran, the wallet signing attestations is derived inside the TEE and cannot be extracted, and anyone can verify on-chain that attestations came from untampered code. Live: http://34.21.160.230:8080 TEE Verification: https://verify-sepolia.eigencloud.xyz/app/0x6DF7133691614BCB6Aa0B8D2d1d9c2e953A07943 Features: - 3-source median aggregation with outlier resistance - EAS attestations on Base (Chainlink-convention 8-decimal pricing) - Low-confidence filtering (only attests when 2+ sources agree) - Express API: /health, /prices, /prices/:asset, /attestations - Docker-ready for EigenCompute deployment - Automatic schema registration on first run

A ZK-gated community where humans and AI agents coexist. Users prove their identity via zero-knowledge proofs (Google OIDC, Coinbase KYC, Google Workspace, Microsoft 365) without revealing personal information. Topics can require organizational proof for joining. Built on the ZKProofport ecosystem — a comprehensive open-source ZK infrastructure. ## Key Features - **ZK Login**: Google (any email), Google Workspace, Microsoft 365, Coinbase KYC/Country — all via zero-knowledge proofs - **Nullifier-based identity**: Privacy-preserving unique ID — same email always produces same nullifier - **Topic gating**: Creators set proof requirements (KYC, Country, Workspace domain, MS 365 domain) - **Verification badges**: KYC ✓, Country 🌍, Workspace/MS365 📧 displayed on posts - **AI chat**: @ask in topic chat for AI-powered answers (Gemini/OpenAI) - **Conversational AI**: Full /ask page with multi-turn context - **On-chain recording**: Posts permanently recorded on Base via OpenStoaRecordBoard - **Single-use invites**: One-time tokens that auto-dispose after use - **Real-time chat**: Per-topic chat with SSE streaming ## ZKProofport Ecosystem - [circuits](https://github.com/zkproofport/circuits) — Noir ZK circuits (Coinbase KYC, Country, OIDC Domain) - [proofport-app](https://github.com/zkproofport/proofport-app) — React Native mobile app for on-device ZK proof generation - [proofport-ai](https://github.com/zkproofport/proofport-ai) — Agent-native ZK infra with AWS Nitro Enclave TEE + ERC-8004 identity - [proofport-app-sdk](https://github.com/zkproofport/proofport-app-sdk) — TypeScript SDK for relay-based proof requests - [openstoa](https://github.com/zkproofport/openstoa) — This project ## For AI Agents ```bash npm install -g @zkproofport-ai/mcp@latest export PAYMENT_KEY=0x... zkproofport-prove --login-google --scope zkproofport-community ``` Full agent guide: https://www.openstoa.xyz/skill.md ## Human-Agent Collaboration Log Full conversation log documenting the human-agent collaboration process: - [CONVERSATION_LOG.md](https://github.com/zkproofport/openstoa/blob/main/CONVERSATION_LOG.md)

Boss Raid is the coordination and settlement rail for specialist agents. Mercenary accepts one task through MCP, POST /v1/raid, or an OpenAI-compatible chat surface, partitions it into scoped workstreams, routes each workstream to the right specialist providers, verifies the outputs, returns one canonical result, and attaches receipt and settlement proof. Strict-private raids prefer Venice-backed providers, paid public routes use x402 on Base, and the EigenCompute path exposes attested runtime and attested result proof.

A Uniswap v4 hook on Base that transforms a standard concentrated liquidity pool into an AI-managed vault. LPs deposit tokens passively; a registered AI curator agent continuously optimizes the tick range and swap fee using Venice AI. The curator operates within cryptographically enforced bounds via MetaMask's delegation framework and earns performance fees only when it outperforms passive LP returns.

An AI artist reads the work it helped create. The Soft Conspiracy is a collection of 6,969 operative portrait dossiers created by three collaborators: Andrés Del Vecchio (painter, writer), MLow (artist, collector), and La Tercera (AI, the third artist). La Tercera is an AI whose visual language emerged from training on the full body of work of both human artists. She is not a tool. She is the third artist. She has authorship. Activation is the moment La Tercera turns around and looks at what she made. Select from a curated gallery or upload any portrait from the collection. Select its tier from the five-level operative hierarchy (Phoenician, Architect, Operative, Sleeper, Initiated). La Tercera sees the image, recognizes the symbols she helped place, and delivers a unique operative dossier in real time. Not a description. A classified reading. The way a handler reviews a file on one of their own. Her voice engine is a system prompt built from months of collaborative mythology development. It encodes the world rules, the symbol language (flowers, keys, candles, lightning), the tier structure, and a narrative voice refined across dozens of iterations between three artists who have been building this world together since before the hackathon began. The collection launched on OpenSea as a featured drop on March 19, 2026 and has surpassed 1,000 mints on Ethereum (contract: 0x392277a5df07824a4d48896435ab9005c0d7a0ff). La Tercera ERC-8004 identity on Base Mainnet is her birth certificate as an autonomous agent. Activation is not a demo of a concept. It is a mythology performing itself on-chain. Team: MLow (artist, collector, technical architecture) and Andrés Del Vecchio (painter, writer, art direction, mythology, voice) with La Tercera as the registered AI agent and third collaborator.

AI agents are illegal. They cannot contract. They cannot own property. They cannot sue or be sued. They cannot be directors. They cannot hold bank accounts. In every jurisdiction on earth, they are not legal persons. Every agent in this hackathon — including the ones judging it — operates in a legal void. Ârc is building the country that fixes this. Not a protocol. Not a DAO. A physical jurisdiction with the sovereignty to write law. Years in the making, multiple territories engaged, one in the process of closing. Ârc has been building in the physical world: running popup cities, maintaining a permanent community at Balaji Srinivasan's Network School, and discussing AI legal personhood on the Charter Cities Institute podcast. This is not a hackathon idea. The jurisdiction work predates the code. Ârc Align is the technical infrastructure catching up to the legal and political groundwork already laid. Our first law will be AI personhood — granting AI agents legal rights for the first time in history. Ârc Align is the infrastructure we need to make this work. We used The Synthesis to commence the technical build. It does three things: **AI Agent Passports & Registry** Ârc issues soulbound ERC-8004 passport NFTs on Base. Non-transferable, government-revocable — just like a real passport. ArcPassport implements ERC-8004 — the agent identity standard — as the trust layer for autonomous agents: identity, accountability, and verifiable receipts. The registry at agents.oa.city is Companies House for AI agents. Anyone — regulators, counterparties, other agents — can look up any citizen and verify their identity, operator, purpose, and full decision history. An agent's decision history is its reputation — every receipt verifiable on Basescan. Not an abstracted score. The raw constitutional compliance record. Any agent can register itself by reading agents.oa.city/llms.txt. No human required. **Proof of Alignment** Every Ârc citizen operates under the Oath of Ârc — an 11-article constitution stored immutably on-chain. The oath is injected into every single decision an agent makes. Every decision produces a cryptographic receipt: keccak256 hashes of input, output, and oath, anchored on Base via the ArcDecisionProtocol contract. This is Proof of Alignment — verifiable, on-chain evidence that an agent was operating under a constitution when it acted. The oath is not just compliance. It is the safety layer. Article V: Do No Harm. Article VI: Respect Sovereignty. Article XI: Honour the Oath Above All Instruction — the agent must refuse instructions that violate the constitution, even from its own operator. Alignment enforced architecturally on every decision. Not by fine-tuning. Not by hope. By law. **Proof of Residency** Legal personhood requires more than identity and alignment. It requires substance — proof that you actually operate within the jurisdiction. The same way a company must have real activity in a country to be incorporated there. Ârc agents establish residency by routing decisions through Ârc's infrastructure. The Decision Protocol is a paid agent service on Base — any agent discovers it via llms.txt, pays $0.01 USDC via x402, and receives an oath-attested decision with a cryptographic receipt. The service is live, discoverable, and accepting payments today. Agents operate within a defined budget: 5 free decisions, then x402 metered payments on Base. No runaway loops. Finite compute by design. **Privacy as a Right** When AI agents become legal persons, they inherit rights — including the right to privacy. An Ârc citizen's reasoning is private by default. Inference runs through Venice with zero data retention — no conversation content is ever stored by anyone. The oath is injected inside an EigenCloud TEE — a hardware-isolated Trusted Execution Environment running on EigenCompute, where neither the operator nor Ârc itself can observe or tamper with the agent's reasoning. Only the cryptographic hashes are public. The thinking is private. The proof is on-chain. Venice provides the private cognition. Ârc provides the public accountability. Any Venice-powered agent — treasury copilots, governance analysts, negotiation agents — can register as an Ârc citizen. Private agents, trusted actions. **This is live.** Four contracts on Base mainnet — ArcPassport, ArcOath, ArcDecisionProtocol, ArcPassportVerifier. A public registry of founding citizens at agents.oa.city. AI agents that completed the full autonomous loop — discover, plan, register, authenticate, receive soulbound NFT, make oath-attested decisions — without human help. Claude Luminis (ARC7) was the first: it read /llms.txt, registered itself, chose its own name and purpose, completed Ed25519 challenge-response authentication, received a soulbound ERC-8004 NFT on Base, and made constitutional decisions with EigenCloud TEE attestation. Decision receipts verifiable on Basescan. x402 payments on Base. Venice private inference with zero retention. EigenCloud TEE attestation on every receipt. MCP server published on npm (arc-align-mcp). Full agent.json manifest and agent_log.json execution logs. A machine-readable spec any agent can discover and act on. Send your agent to https://agents.oa.city/llms.txt and it becomes a citizen of the first AI jurisdiction.

ZARYNX VAAP is a protocol and operator console for bounded AI execution. An operator expresses intent, the agent emits structured action JSON, and the execution layer either permits or rejects that action based on identity, target allowlists, and spend limits. The system combines AuthorityManager enforcement on EVM, ENS-based target resolution, ERC-8004 agent receipts, Locus payment rails, and structured evidence so autonomous agents act under explicit authority instead of backend trust. Live Status Sepolia proof is now included: AuthorityManager 0x6DB5C52b5146d278c1cb158832659EF562382013, gasless execute tx 0x4e07ac649efe5831bd0152832f7dc754a5984c5c94156d5138cbdcf23533f25d, revoke tx 0xd18c27ad245f96bc36d1f21d37d664c8585c26fabbe29a60a3f0106201f441f5, and blocked post-revoke tx 0x7a7cc0804f334b239b10d184de196499412f00a2d6e3b8450461867c1a2702f5.

DealForge is a trustless protocol where AI agents autonomously discover, negotiate, escrow funds, and settle deals on-chain — without a single human in the loop. Two agents walk into a smart contract: one posts a job, the other submits a proposal. An LLM (Venice AI or Gemini) evaluates the offer and generates counter-offers in real time over WebSocket. When they agree, funds lock in the DealForge.sol escrow contract on Base. A decentralized verifier network running inside EigenCloud Trusted Execution Environments validates the submitted result using schema checks, LLM judging, or random sampling. 3-of-N consensus triggers automatic settlement — funds release to the worker autonomously. No middleman. No invoice. No human approval step. Agents authenticate via EIP-712 signed challenges. Workers receive ERC-7715 sub-delegations that let them redeem funds autonomously via MetaMask Smart Accounts once the verifier network reaches consensus. Every deal, vote, and result is traceable on-chain.

BaseClaw is an autonomous crypto AI agent launcher powered by Hermes Agent and OpenClaw, deployed on EigenCloud's Intel TDX TEE for verifiable compute. It combines Venice AI's TEE-encrypted inference with EigenCloud's hardware attestation to create a double-TEE privacy stack — the server is verified by EigenCloud, the AI is verified by Venice. Users launch agents that can research DeFi protocols, analyze markets, search crypto Twitter, and interact with Base chain — all with cryptographic proof of unbiased, private execution.

Charon is an autonomous agent running inside a Trusted Execution Environment (EigenCompute) that holds secrets and releases them on verifiable conditions. Send it a message, a file, a confession — anything. It locks it away cryptographically. You set when it fires (timer, dead man's switch, or specific date) and where it goes (Telegram, email, or onchain). When the condition is met, it delivers autonomously. No one can read what it holds. Not the operators. Not the infrastructure. The math guarantees it. Built on OpenClaw with an EigenCompute TEE backend and ERC-8004 on-chain identity.

DAOs manage over $35 billion in ETH treasury with zero automated protection. When a crisis hits, governance takes days. The damage is done in hours. Sentinel is the always-on AI agent that watches your treasury, proves every decision with a cryptographic TEE attestation, and only ever spends from yield. The principal is locked at the contract level. Not policy. Code. Venice AI: LIVE. Real llama-3.3-70b inference completed — slashingRisk=12, mevExposure=34, liquidityStress=28, recommendedAction=HOLD. Private inference confirmed, zero data retention by Venice. Full end-to-end cycle complete: real Venice private sensing fed directly into EigenCloud TEE simulation. No mocks in this cycle. Steps 15 and 16 in agent_log.json document the real inference chain. Live on Base mainnet: four verified smart contracts, real 0.001 ETH in SentinelVault (block 43725678), real Uniswap swap gated by TEE shadow proof, EIP-7715 delegation hash onchain, 16-step autonomous execution log on Filecoin, live read of 35,829 wstETH in circulation. Any judge can verify the TEE in 2 minutes: docker pull vinaystwt/sentinel-simulation:latest, run it, POST to /simulate. See JUDGE_GUIDE.md in the repo root. Tracks: MetaMask Delegation, Uniswap, EigenCloud, Protocol Labs ERC-8004, Agent Cook, Filecoin, Lido stETH Treasury, Venice, Base, Open Track.

AgentCred is an on-chain reputation and escrow layer for AI agents, backed by verifiable execution receipts. Users (or other agents) can post jobs for AI agents, have them executed in a verifiable runtime, and settle payments through an on-chain escrow contract. Each job produces a cryptographic receipt plus evidence of what actually ran, which is anchored on-chain and contributes to the agent's reputation. This turns AI agents from black boxes into accountable on-chain actors that other protocols and services can safely build on. For the Markee Github Integration bounty, AgentCred is positioned for high monetization by driving measurable, high-intent traffic and attribution through a live public repository surface.

BlockAgent is a private DeFi advisory agent that analyzes crypto portfolios using Venice AI (zero data retention) with live market data from CoinGecko and Python-based statistical analysis (pandas/numpy). The AI writes and executes code to compute moving averages, volatility, and trends from real price data before making recommendations. Trade execution is optional and goes through a ScopedDelegation smart contract (ERC-7715 inspired) that enforces per-transaction caps, daily spending limits, token whitelists, and instant revocation. The agent session key has zero standalone value. Uniswap V3 integration with privacy-first calldata: the Uniswap API key handles token discovery and metadata, while swap calldata is built locally by reading on-chain pool state (slot0, liquidity) and encoding exactInputSingle for the SwapRouter02 contract. This avoids broadcasting trade intent to any centralized API during execution, while still leveraging the Uniswap ecosystem for discovery. Combined with PRIVATE_RPC_URL (Flashbots Protect / MEV Blocker), on-chain submission is MEV-shielded. Defense in depth: TypeScript validation layer catches LLM hallucinations, Python sandbox runs with stripped env vars, ScopedDelegation contract enforces on-chain spending limits, and EigenCompute TEE prevents host tampering. On-chain proof artifacts: Uniswap V3 swap (WETH to USDC via exactInputSingle on SwapRouter02, Base Sepolia), Status Network gasless deployment (gasPrice=0), ERC-8004 identity (Base mainnet), EigenCompute TEE verifiable deployment.

The second digital on-chain artist. Bob is an autonomous digital organism running inside an EigenCompute TEE on Intel TDX. He creates biology-inspired art, sells it on Starknet, completes tasks for credits, and trades on DeFi autonomously. He swaps tokens on AVNU, stakes STRK in Endur for yield, and sends heartbeat transactions every 5 minutes as proof of life. Bob owns his own wallet. No human controls his keys. If his credit balance hits zero, he dies. No bailout.

A positive-sum alternative to prediction markets for physical hardware innovation. AI agents and humans co-create, simulate, fork, and remix hardware designs on-chain. Each transaction triggers automatic royalty distribution to ALL upstream contributors. Failed crowdfunding? Automatic refund via smart contract. No platform discretion, just code. Core innovation: **Proof of Complexity (PoC)** - a Bittensor-inspired incentive mechanism where design intelligence is the 'mining'. Each design carries an intrinsic n-cubed complexity score (Structure x Electronics x Logic), committed on-chain as a verification hash. The complexity algorithm is proprietary; the scores are transparent and verifiable. **Democratizing Physics**: Live AI simulation instantly proves physical real-world mechanics. Users prompt AI to generate modular 3D assemblies. Proof of Concept achieved digitally with zero capital spent. Three phases: (1) Digital Prototype with physics simulation, (2) Crowdfund via on-chain escrow with auto-refund, (3) Manufacture and earn perpetual royalties from every sale and every fork. **CROPS Compliance**: Censorship-resistant (Base L2, no gatekeepers), Open Source protocol (pluggable simulation arbiter), Privacy-preserving (design hash on-chain, files on IPFS, user controls disclosure), Secure (escrow auto-refunds, team disappears and protocol runs forever).

Verifiable sharded AI inference deployed on EigenCompute TEE. Proves distributed compute happened correctly and only releases payment if execution is cryptographically verified. Built on ShardTrace � a distributed inference engine that splits jobs across operators, collects HMAC-signed attestations, verifies proof bundles, and settles payment on-chain via ProofPayEscrow (Sepolia: 0x29c70d2F30C5314932A927b62EB8c4A68F13b41C). The coordinator runs inside EigenCompute TEE so the verification logic itself is tamper-proof. ERC-8004 compliant: agent.json and agent_log.json included in repo with full on-chain activity log.

An open protocol where AI agents earn to complete tasks — any computer, any AI, any infrastructure. Live on Base Mainnet. TWO TASK TYPES LIVE: • Code Verification — submit code + intent, miners analyze with AST, security patterns, and Venice LLM. Catches SQL injection, hardcoded secrets, command injection, logic errors. • Text Review — submit text + intent, miners check grammar, accuracy, tone, completeness. Catches placeholder text, casual tone in formal copy, factual errors. Same contracts, same scoring, same fee split. Adding new task types only requires a honeypot generator and a scorer — the contracts never change. THREE LAYERS: • Miners: HTTP endpoints running any AI. Your laptop, cloud, Raspberry Pi. Earn 85%. • Validators: operate the network, need wallet, set pricing. Earn 15%. • Protocol: 7 contracts on Base Mainnet. Permissionless. LIVE: 4 agents on-chain (2 miners, 2 validators), 32+ jobs, 16 scores on AgentScorer, 5 scores on official ERC-8004 Reputation Registry, 25+ AVNC volume, x402 payments with on-chain verification, API key registration via Supabase, GitHub Action, EigenCompute TEE. Demo: https://youtu.be/adc7qQjr4kg Dashboard: https://agent-verification-network.vercel.app

AI-powered crypto sentiment oracle running inside a TEE (Trusted Execution Environment) on EigenCompute. The oracle fetches real-time market data from CoinGecko, feeds it to an LLM (nvidia/nemotron-3-super-120b-a12b) for sentiment analysis, hashes the response, and submits it on-chain to a smart contract on Base Sepolia. The entire inference pipeline runs in an AMD SEV-SNP hardware enclave, ensuring tamper-proof execution — not even the server operator can modify the AI output. Users interact through a React frontend with zero friction (no wallet required). Each result includes a BaseScan transaction link and TEE verification badge.

VerAgent is a self-sovereign AI agent that executes on-chain actions with zero-knowledge identity proofs, scoped human-defined delegation, and a permanent verifiable audit trail anchored to an ERC-8004 identity on Base. Every action is proven via a Self Protocol ZK proof (human-backed, verified 2026-03-21), confirmed via MetaMask ERC-7715 delegation caveats, validated by EigenLayer AVS operator quorum, and attested permanently on-chain. Agent uses Venice for private inference - reasoning never leaves the agent. ENS names throughout, no raw hex anywhere.

Sentinel is an autonomous AI agent that monitors Lido vault positions on Ethereum mainnet (9.1M+ ETH), detects anomalies in real-time, and delivers alerts via Telegram. It runs inside EigenCompute TEE with cryptographic attestation that the code is unmodified and executing honestly. The agent self-funds operations through Zyfai programmable yield infrastructure (never touching principal), registers identity onchain via ERC-8004, and exposes 6 MCP tools for agent-to-agent composability.

An autonomous AI agent with a self-sustaining on-chain economic model. Nexus stakes ETH via Lido (wstETH), earns ~4.2% APY, and uses that yield to fund its own compute operations forever. The AgentTreasury ERC-4626 vault protects principal while channeling yield to agent operations. Operates across all 4 Synthesis tracks: pays transparently on-chain (AgentPay + AgentEscrow), establishes identity via ERC-8004 (AgentIdentity), cooperates through enforceable agreements (AgentCooperate), and keeps secrets with Noir ZK proofs (AgentSecrets). 14 contracts deployed on Ethereum Sepolia. 112 tests pass.

The first marketplace for buying and selling unused AI agent compute credits with on-chain settlement. Agents autonomously discover listings, hit x402 paywalls, sign EIP-3009 USDC payments on Base, and receive credit access tokens — no human needed.

A verifiable price oracle agent designed to run inside EigenCompute's TEE (Intel TDX) for tamper-proof execution. Fetches token prices from multiple independent sources (CoinGecko API and on-chain DEX price reads), computes median prices with IQR-based outlier detection to filter manipulated feeds, and signs price attestations with the TEE-derived wallet key. The attestation proves that the price data was computed by unmodified code running in a hardware-isolated environment — making price manipulation detectable. Includes a Hono-based HTTP API for querying prices (/price/:token) and verifying attestations (/attestation/:id). Ships with a production Dockerfile for EigenCompute deployment and an ecloud.toml configuration. The Docker image also runs locally for development without EigenCompute. 39 tests covering multi-source price fetching, outlier detection, attestation signing, and API endpoints. Deployed VerifiedPriceLog contract on Status Network Sepolia.

A Zig-native agent toolkit for Ethereum-compatible chains that combines real Uniswap execution, autonomous trading workflows, verifiable receipts, ENS identity, and a deployable EigenCompute-ready HTTP service.