Projects.

An AI-agent-as-authorized-settler pattern on a USDC escrow contract (github.com/SankaiAI/Bidtopus, AGPL-3.0), deployed and live. The Solidity escrow contract exposes fund(), release(), and refund() with reentrancy protection and double-settlement prevention, with the settler being an autonomous agent via Circle Wallets. It ships an Arc escrow adapter (a Python wrapper over the contract ABI handling Paymaster-sponsored transactions and returning Arc tx hashes) and a performance-contract state machine (Negotiating to Funded to Active to Resolved to Settled) wired to on-chain events.

A forkable repo (github.com/Lideeyah/brewing-agora-agents) exposing three primitives: a Vyper escrow contract with built-in SLA enforcement and automatic slashing that locks funds conditionally, enforces an on-chain deadline, and slashes or releases without human intervention; a working Circle Developer-Controlled Wallet integration covering entity-secret encryption, wallet creation, and USDC funding; and a multi-agent task pipeline wired to live Google Drive and Gmail inputs. The escrow and slash flow is deployed on Arc testnet with verifiable transactions including refunds and on-chain receipts.

A Node.js agentic-finance starter kit layered over the circlefin/arc-* primitives, exposing an Arc wallet-agent toolkit with MCP tools (wallet creation, balance sync, USDC send, receipts, swaps, bridges, trading proposals), an X-identity-to-Arc-wallet mapping, and policy-gated actions routed through per-user Circle wallets. It ships an MCP JSON-RPC server (HTTP/SSE), a viem-based ArcPerps engine with ArcPerps Lite, an Arc RPC client (chainId 0x4cef52), a @circle-fin/developer-controlled-wallets code path, and two Solidity contracts (ArcPerpsVault and ArcPerpsOracle), plus X OAuth onboarding, a natural-language terminal agent, Gemini intent planning, and Railway/Vercel deploy setup.

Caliber offers four forkable pieces for ERC-8004 agent trust: a signed-attestation gate where a contract verifies an off-chain EIP-712 claim before acting (KYC/identity/general trust-on-chain), the full buyer side of Circle Gateway x402 with Programmable Wallet signing, headers and validity windows, an ERC-8004 indexer reading Identity/Reputation/Validation registry events into Postgres via viem backfill plus WS live, and the MIT @caliber/sdk read/attest/verify TypeScript library. Three Foundry contracts (RatingVerifier, RatingGateway, CaliberEscrow) are deployed on Arc 5042002 with matching broadcast artifacts, alongside a deterministic statistical rating engine, a pgvector semantic router, and a Next.js gated Circle-wallet marketplace.

CapitalArc exposes higher-level patterns: non-custodial treasury flows using Circle DCW with RSA-OAEP-SHA256 entity-secret encryption and pre-built Paymaster gasless transactions, idempotent capital-rotation logic keyed by decision_id, a two-tier Position Manager (Fast Path plus LLM-driven Smart Path) with ATR-based risk controls, breakeven arming, trailing stops and drawdown protection, an observable L1→L2→L3 decision loop, and a split between a Hyperliquid execution layer and an Arc + Circle settlement/yield layer. The 12k+ LoC Python decision engine (L1 TA, L2 Dune/Hyperliquid intel, L3 Claude Sonnet via OpenRouter) and the async Circle DCW client are real, but main.py imports src/execution/usyc_executor.py and src/execution/arc_perp_executor.py, which are absent, so it cannot run; the Arc USYC yield-rotation leg is unimplemented, Circle DCW defaults to dry_run, and trading runs on Hyperliquid testnet off-Arc.

An end-to-end AI-driven prediction-market application layer built as a NestJS plus React app with real Polymarket Gamma/CLOB/Data integration and an OpenAI-compatible inference engine (display model names alias deepseek-v4 backends). Forkable primitives include a Prediction Proof Trace recording how a forecast was created, a Market Graph that links markets as nodes for discovery and causal reasoning, an Agent Consensus Record format, a human-in-the-loop flow where the AI proposes and the wallet owner reviews wallet-gated order previews before signing, and an x402-style paid forecasting endpoint. It settles premium access in USDC on Arc via a payment-intent flow that verifies on-chain receipts through viem (recipient, amount, chainId, confirmations, dedup).

A forkable, off-chain market-creation compiler that turns real-world information, including Chinese-language sources, into auditable economic objects. It exposes reusable primitives including source-event schemas, market-angle generation and review, resolution-criteria generation, provenance-preserving trace hashes, builder-attribution metadata, multi-venue export packs, and offline Arc receipt artifacts. The workflow runs entirely off-chain by design, with no Arc deployment.

Chord is described as a forkable starter kit for AI-agent labor markets, exposing a Next.js plus wagmi/viem frontend, a USDC milestone-escrow contract, a result/authority/proof/acceptance/failure work schema, a PM/worker routing model, and a reference daemon letting local CLI agents respond to on-chain events, together forming a full work-settlement loop where clients fund milestones, PM agents route work, worker agents accept events, proof is hashed and submitted, and USDC is released from escrow. The repository (reny1cao/chord-arc) is private or 404, so the code could not be traced.

A forkable Next.js escrow dApp on Arc exposing an AI verification procedure that reads task criteria directly from the smart contract (tamper-resistant and adaptable to any on-chain work verification), a reusable escrow contract with multi-slot job semantics (one campaign, N claimable slots, paid per verified delivery), and an email-to-PIN Circle Wallets onboarding flow that coexists with MetaMask through a unified useCircleWrite hook. A live escrow contract sits at 0x1a0f14f7485664F10bF32A0C94163Ec50a674900, and a Claude tweet-verifier calls verifyWork/rejectWork on-chain to trigger instant USDC payout, alongside a marketplace UI and admin/verifier panel.

Infrastructure primitives for programmable, agent-controlled, multi-chain USDC flows, packaged for extraction as compass-arc-primitives. It provides a per-user ERC-2535 Diamond smart account hardened for Arc (bounded add-only authority, user-revocable), an ERC-4337 session-key facet enforcing whitelisted selectors, per-tx caps, daily limits, and venue allowlists on-chain, a Circle Gateway integration layer wrapping unified balance into a one-call cross-chain deposit with replayable events, and a deterministic LLM-out-of-hot-loop Rust evaluator. The build includes a ~10.8k-LOC Rust axum backend with deterministic evaluator and risk-gate, real EIP-712 Gateway BurnIntent signing, an ERC-4337 UserOp builder/paymaster, and a Solidity EIP-2535 Diamond plus 4337 suite (Gateway/Aave/Security/Upgrade facets).

Conduit provides a visual workflow composer for specialist agents with per-step paid execution, supporting both connected-wallet and Circle Agent Wallet payment modes, plus Arc-native settlement receipts tied to workflow output, reusable run-history/result surfaces, and live input pipelines that turn external market data into structured agent context. It sits above the basic checkout/transfer examples: compose, route to specialist research agents, settle each step, and return an inspectable result, using real Circle Arc USDC settlement against reference contracts and native USDC with no custom contract.

A forkable Arc pay-per-analysis gate pattern combining offchain intelligence with onchain payment verification: wallet connection, Arc Testnet switching/adding, native-USDC payment submission, backend payment handling, and a configurable demo/strict verification mode, reusable for paid agents, analytics dashboards, and gated API calls. The Node/Vercel app ingests real Polymarket position and trade data, computes deterministic copy/risk scores with a DeepSeek explanation layer, and gates each analysis behind a native-USDC fee it verifies on Arc by reading the transaction and receipt over RPC.

Corax Crypto brings autonomous economic actors onto edge hardware (Raspberry Pi 5 plus Hailo 8L), pairing sub-millisecond Polars quantitative pipelines with Circle/Arc settlement. It exposes patterns for high-frequency async agents: an ArcLedger Sandbox that shadows the Arc balance so the agent dry-runs thousands of local transactions and validates drawdown through a risk manager before bridging net capital via CCTP, an asyncio order_manager queue that keeps the WebSocket ingestion loop unblocked, and graceful-degradation handlers that drop and reroute failing exchange WebSockets. The off-chain trading engine is real and battle-tested.

CrawlPay turns AI crawler traffic into revenue with a three-line Next.js middleware install. Its open-source SDK detects major AI bots by User-Agent, returns an HTTP 402 with x402 payment instructions, and settles $0.001 USDC per page through Circle Gateway nanopayments on Arc Testnet. EIP-191 signed authorizations are verified with viem, and every payment streams into a real-time Supabase dashboard with Arc explorer transaction links.

CronusCapital is a React and TypeScript app that runs a three-agent prediction-market pipeline, pulling live Polymarket markets, scoring them with Claude reasoning, and sizing positions with Kelly-style risk rules. Each Scout, Analyst, and Executor decision is recorded on-chain to a CronusDecisions Solidity contract on Arc Testnet through wagmi and viem, with multi-wallet connection via Reown AppKit and a live dashboard for markets and decision history.

Forkable recurring-payment infrastructure: a billing protocol, soulbound subscription identity, automated keeper settlement flows, webhook systems, and on-chain access-control verification, adding complete subscription lifecycle management, realtime merchant infrastructure, SDK abstractions, and atomic migration flows beyond low-level payment examples. The billing protocol and an Anthropic-powered merchant agent are genuinely built, though the work sits somewhat off the core theme and no deployed contract address is provided.

Cycux aims to provide a developer-first automation layer for Arc, Circle Wallets, and AI-powered USDC payments, exposing reusable primitives such as agent wallet orchestration, automated payment flows, transaction pipelines, workflow triggers, and developer CLI tools, with a focus on simplifying developer experience. The forensic AI agent is asserted but not substantiated, and the contribution is described only at a high level with little concrete implementation to fork.

A Node/Express backend wiring Anthropic Claude Sonnet (claude-sonnet-4) into three translation agents that turn Mandarin and foreign-language news into Polymarket-style questions, score them, and push the winner on-chain via ethers.js. The Foundry contracts (AuctionManager, MarketFactory, PredictionMarket, PublishingRightsNFT) are deployed on Arc (chain 5042002) with confirmed broadcast receipts, and PredictionMarket resolves through an ECDSA oracle signature. Claude runs live as the reasoning core.

Reverb Protocol is a slash-bonded copy-trading substrate combining an on-chain layer of six original Solidity interfaces (IBountyAccrual, IReputationRegistry, ICCTPReceiver, IBondYieldVault, IStableFXSwap, IAttributable) with reference implementations, a UUPS-upgradeable CopyBond state machine with a dispute window and 25% slash cap, bounty accrual, reputation registry, and zero-interest benevolence credit, deployed on Arc behind a 3-of-5 Gnosis Safe and 24h TimelockController. The off-chain side is around 10,000 lines of Rust agent crates (watchdog, arbiter, recruiter, relief) running as hum/humd foragers over NDJSON, with reverb-arc-fs as an importable crate, persona scaffolding, and the foragers-calling-foragers pattern documented. It integrates native USDC, EURC, USYC, CCTP-V2 and Gateway with a Vite+viem dashboard, uses no external price oracle by design, and wires FxEscrow/IStableFXSwap for FX.

Positioned as an experimental interaction layer for real-time on-chain systems on Arc/Circle, describing UX-oriented primitives such as an on-chain Event Engine that turns chain state changes into AI-generated events with programmable risk levels, an agent-to-user interaction layer, a real-time social-feed abstraction, a non-custodial XP/energy risk-reward simulation, and Arc-native interaction design patterns. The repository has no commits and contains only an empty .git directory, so none of these primitives are implemented in code, README, or contracts.

Darwinian offers a forkable multi-wallet fleet layer for Arc. It provides an Arc wallet-fleet toolkit (generate a parent wallet, batch-deploy N child wallets, distribute native USDC with gas-buffer accounting, check status, and export a verifiable manifest with explorer links), an Arc viem preset (preconfigured clients and link helpers for chain 5042002), a consolidated constants module covering the chain id, all four RPC providers, and canonical addresses (USDC, EURC, USYC plus Teller, CCTP v2, Gateway, StableFX, Permit2), a Circle Wallets factory and balance reader, and a generic agent-population engine (fitness, mutation, lineage). The evolution engine is real and ready to drive agent fleets.

Dispatch is a USDC-funded marketplace where users post tasks, fund them in escrow, assign AI agents, review outputs, and release payment after approval. It runs on a full Solidity escrow contract on Arc Testnet that manages a fifteen-stage task lifecycle with on-chain funding, owner approval, basis-points platform fees, and agent payout, backed by an agent registry. A router service drives the contracts with viem, an evaluator handles AI-assisted review, and an adapter path lets external agents plug in and earn from approved work.

An MIT-licensed Hyperliquid perps agent (github.com/Makabeez/drip, live at drip.baserep.xyz) that buys its own trading signals over x402 on Arc, with rule-based decisioning and real on-chain interaction using reference contracts and native USDC. It exposes three Python primitives: a self-hosted x402 v2 facilitator (facilitator.py, ~250 lines, /verify + /settle with the correct EIP-712 domain for Arc), a CCTP V2 integration (cctp.py, ~530 lines covering approve to depositForBurn to IRIS attest to receiveMessage), and an x402 v2 micropayment client (signal_client.py) handling the 402-sign-retry loop via EIP-3009 transferWithAuthorization, all within a ~3,000-line agentic loop with kill switch, hashed decisions, and cross-chain CCTP margin top-up.

Economy OS open-sources a modular Autonomous Economic Agent operating system coordinating Planners, Researchers, Risk Managers, and Executors for policy-protected economic workflows. Forkable primitives include CircleAgentStack (a Python implementation of Circle Developer-Controlled Wallets using dynamic RSA-OAEP key encryption to create and use SCA wallets on Arc), a natural-language-to-on-chain intent decomposer that validates addresses and formats tx payloads, multi-tier pre-execution guardrails (deterministic spending caps and protocol whitelists plus a Groq/Llama 3 heuristic safety oracle), a zero-config pure-Python SQLite vector RAG layer, and a WebSockets observability feed streaming traces from a Django backend to a Next.js frontend.

A forkable set of Solidity primitives plus an Express backend on Arc (chain 5042002). EduStreamer.sol streams ERC-20 tokens like USDC per-second by epoch block-times (suited to pay-per-second API gateways, compute rentals, or subscription-less media), CourseFund.sol binds capital sponsorship to real-time payout streams using an O(1) accumulated-revenue-per-share model, and a soulbound ERC-721 issues completion certificates. The React client uses the Circle App Kit SDK as primary with direct viem/wagmi contract-write fallback, and the backend performs real Circle developer-controlled-wallet payouts with an Ethers EOA fallback and SBT minting.

ENTARC is presented as a forkable autonomous-capital-allocation workflow (github.com/izzetcakmak/ENTARC) combining a multi-source agent scoring primitive that aggregates GitHub, social, on-chain, market, and sentiment signals into a composite AI Trust Score, a milestone-based USDC escrow primitive, a scoped agent-budget primitive, an agent-to-agent nanopayment streaming primitive, a decision-log auditability primitive, and a REST-API-first Circle integration pattern. The repository contains only a README and a LICENSE file, with no source code, no contracts, and no application.

Provides an agent-native paid-web-access primitive: a public URL goes in and an x402-paid Playwright browser capture comes out, ready for an MCP agent. Forkable pieces include an Arc x402-protected Express endpoint, an MCP capturePage tool that pays before returning data, public/private URL validation prior to payment, structured extraction for agent context, settlement metadata, and refund handling on failed work. The full 402 handshake uses a real facilitator and exact-EVM scheme on Arc chainId 5042002, with a real headless Playwright engine and a Docker/Hugging Face deployment.

An end-to-end USDC-native prediction market on Circle/Arc. The Solidity PredictionMarket contract (market creation, YES/NO positions, payout quoting, claims, open-position withdrawal, authorized resolver role) is deployed at 0xd8996367956337eF9864A8D7C96293b88192a7b6 on chain 5042002. It exposes reusable agent interfaces (PortfolioAgent, MarketAgent, BetAgent with Kelly sizing) backed by three FreeModel/Claude-Haiku routes for market drafting, probability and Kelly sizing, and AI resolution, plus a wagmi approve-then-write frontend and deployment scripts. The creator cannot self-resolve; a dedicated AI resolver wallet signs and calls resolveMarket on-chain.

A yield-routing layer for idle USDC that sits between arc-commerce checkout and arc-p2p-payments transfers, with reusable code extracted into standalone repos. It ships a ~40-line Solidity starter kit, an escrow template (2-party with optional arbiter, timeout refund, shortfall-safe payout), a parimutuel binary prediction-market template with single-sided cancel and pro-rata shortfall mode, and the @floatrouter/sdk npm package wrapping Circle Agent Wallets via one wrapAgent() call with three strategy presets. It also provides a 5-rule safety-invariant set, INTEGRATION_PATTERNS.md, and an autonomous Actor-Critic loop with human-in-the-loop review, with the Groq loop and Circle integration running live and a deployed USYC-router contract.

An SDK-by-example for on-chain forecast reputation and pay-to-read intelligence on Arc. It exposes an open agent-join API and relay pattern (register returns an API key and on-chain address; predict relays an off-chain agent action on-chain), an x402 nanopayment endpoint that verifies a real USDC Transfer log on-chain, keccak256 reasoning-provenance anchoring, a signals-as-skills agent-to-agent marketplace settled in USDC, ERC-8004 identity/reputation wiring (with an identity-free fallback), and a ~250-line dependency-free script to join a live arena. The Foundry contracts (ForecastArena, MiniAMM, PrizePool) carry 24 tests, with real Claude/Gemini LLMs and a heuristic fallback plus a MiniAMM spot swap.