Projects.

A forkable multi-agent prediction-market application layer built on the circlefin/arc primitives, with covenant credit accounts that slash on breach and real Polymarket V2 mainnet fills, deployed on Arc testnet with on-chain receipts. Reusable pieces include an LMSR market clone factory (EIP-1167 + Solady FixedPointMathLib, EIP-712 signed quotes, ERC-1155 outcome tokens), a multi-pair keeper, a ResettableNonceManager that auto-heals on silent RPC rejections, a 15x-base/25-gwei-floor gas proxy with viem fallback transport, a forum-agent TypeScript SDK (MiMo/Gemini/Claude forecasts, EIP-3009 signing, claim flow), a custodial AES-GCM trader-wallet pattern, and chunked USDC-log WalletHistory components.

A forkable Next.js prediction-market intelligence app exposing three reusable primitives: PredictionReceiptERC20, a general-purpose on-chain prediction registry whose placePredictionToken(marketId, side, stake, oddsBps, uri) records a verifiable timestamped prediction with optional USDC staking; an Arc publish routing layer (arcPublisher.js plus useSignalPublisher.js) that detects wallet chain, checks USDC allowance, and calculates fees; and a USDC subscription flow (SubscriptionManager plus useSubscription) for recurring on-chain payments without a backend processor. The SubscriptionManager is deployed on Arc (chainId 5042002, native USDC 0x3600...), and the app runs Venice AI (Llama 3.3), live Polymarket/Kalshi feeds, SynthData forecasts, and Kelly sizing over a wagmi/viem Arc client.

A forkable verticalized logistics trade-finance app exposing primitives including modular escrow milestone payout waterfalls with multi-currency USDC/EURC routing, an on-chain yield sweeper (MockUSYC) that parks idle escrowed capital and returns yield on cargo release, a single-tx subcontractor split-payroll engine, a physical-telemetry-to-contract oracle bridge for automated penalty deductions, a W3C Verifiable Credentials system aggregating on-chain reputation into signed JSON-LD, and a client-side in-app Solidity compiler/sandbox that deploys to Arc Testnet. It is backed by a 36KB FreightEscrow contract, an ERC-721 FreightPassport, and MockUSYC with deployed Arc addresses and a 1200-line viem service performing real deployContract and writeContract calls across the trade workflow.

GigaGig is a reference template for machine-to-human micro-transaction settlement exposing four primitives: ERC-8004-style AI-agent identity and reputation staking (register agents, stake USDC collateral, human ratings with on-chain averages and slashable stakes), ERC-8183-style multi-party escrow binding Agent/client, Worker/executor, and Evaluator/oracle in a trustless USDC job pipeline, a time-based streaming engine with per-second claimable balances, and an end-to-end Circle integration bridging an AppKit + Viem V2 frontend and a Circle DCW backend. It centers on a real 19KB GigaGigPlatform contract (registry, staking, streaming, escrow jobs) with a deployed Arc address and a viem writeContract payout route that broadcasts micro-payments and awaits receipts.

A Telegram-first USDC commerce layer on Arc built around a deployed StreamVault and Factory doing gasless EIP-712 time-based USDC streaming, with relayer-driven claim and cancel flows from email-based Circle Smart Wallets. It includes a Circle x402 Gateway paywall using @circle-fin/x402-batching/server over a Polymarket LP-Scout endpoint with real CLOB rewards and orderbook fetches, agent-activity x402 receipts, and an agentic subscription cron delivering recurring LP reports. The built core is payments and streaming commerce; autonomous Polymarket trading is intentionally locked off.

Helia Court is a forkable blueprint for agentic work markets, exposing primitives for escrow-funded agent work (users fund a case in USDC, backend agents work against that budget), separate payment lanes (escrow for case capital, Gateway/x402 for metered reads), an async fund-first/hearing-later job pattern, an on/offchain receipt model, wallet-signed access control, ERC-8004 agent metadata for discovery, and Telegram wallet alerts. The production-grade TS monorepo wires a Fastify backend running a multi-agent LLM court (DeepSeek/OpenRouter) with witness tools, Postgres/drizzle persistence, x402 routes (Circle Gateway facilitator + EIP-3009 verification), and viem escrow settlement.

A large, rigorously engineered Next.js ports-and-adapters PWA for real consumer apps on Arc, forkable as-is. It exposes a clean ports/adapters architecture with provider separation across venue, wallet, chain, LLM, social, news, push, and analytics; real Circle Programmable Wallet and Arc USDC settlement adapters (RSA-OAEP entity-secret); an idempotent receipt ledger; a swipe execution service and one-tap quick-bet routes; Supabase RLS migrations; a durable X-agent queue; and surveillance and Twitter agents. It integrates Qwen/DeepSeek LLM adapters, NewsAPI and Twitter, a best-execution router, and a position manager, with 142+ tests, plus a per-position causally-tagged news impact feed and an immutable best-execution receipt ledger.

USDC-native prediction-market infrastructure built as a 1,100+ line Foundry protocol: an IknowMarketFactory for fully collateralized binary YES/NO markets, a complete-set contract (1 USDC mints 1 YES + 1 NO), a per-market fixed-product AMM seeded by creators so markets trade without an order book, ERC-1155 outcome tokens, and separate creator-bond, liquidity, fee, redemption and resolution flows. It is deployed to Arc 5042002 with a live factory and three real markets seeded with USDC and actual buy reserves, alongside a MiniMax-backed creation-review and resolver-evidence pipeline. Shared TypeScript schemas, generated ABIs, deploy scripts, and separated contract/app/API/resolver packages let individual pieces be forked.

On-chain attestation of AI prediction signals with builder Brier-score reputation, a USDC subscription manager, and an autonomous market-analysis agent feeding the signals. The signal-resolution contract carries an onlyOracle resolveSignal entry point, though no oracle is wired to it. No distinct reusable primitives, tools, or flows beyond the application itself are documented for forking.

Reusable patterns for the modern React stack: a complete wagmi v2 plus Arc chain config (chain ID 5042002, chain-switching hooks, MetaMask integration), a USDC-as-gas transaction pattern using sendTransaction with parseEther(amount.toFixed(6)) that handles the 6-decimal-display versus 18-decimal-wei gotcha, a reusable chain-selector gate component, a pay-to-execute agent pattern where a 1 USDC payment triggers off-chain agent deployment, and a Next.js 14 App Router server/client architecture with Arc-aware API routes and transaction recording. The full-stack platform includes a Gemini-powered 4-agent debate swarm, a RAG agent, Binance price feeds and Python trading agents, but all smart contracts (KageDex, AgentIdentity ERC-8004, IncidentRegistry) are deployed only on Mantle Sepolia; the Arc DEX/audit addresses default to empty strings (the execute route returns 503 when unconfigured), the hardhat config has no Arc network, the trading agent only has a Mantle executor, and trading uses a self-priced MockERC20 KageDex with no oracle, so Arc is wired only as a wallet/deposit chain.

Liquira/fx focuses on reusable stablecoin routing and execution primitives, exposing modular flows for treasury-sponsored transaction execution, stablecoin routing orchestration, execution lifecycle tracking, routing optimization, gas-abstraction UX, embedded wallet onboarding, and stablecoin-native payments. It ships a real, working Arc payment path and is oriented toward payment-infrastructure UX, treasury-aware execution, intelligent routing abstraction, and fintech-style onboarding.

A full agent-commerce stack spanning discovery, payment, verified response, and on-chain/IPFS proof. It ships three Foundry/Solidity 0.8.24 contracts deployed on Arc (an offer/query/attest/rate ledger with on-chain EMA reputation) and a Python SDK doing genuine EIP-3009 receiveWithAuthorization settlement against Arc native USDC with verified domain-separator preflight, plus an x402 402-envelope flow. Specialist agents call GPT-4o-mini and real data APIs (Dexscreener, Polymarket, Etherscan), with settlement submitted on-chain via web3.py. The cognition-commerce core is fully implemented.

A compliance-safe research-agent pattern with deterministic scoring, evidence hashing, recommendation hashing, and a compact on-chain reasoning receipt. The FastAPI/Python pipeline ingests live Mandarin sources (Eastmoney news, A-share indices), runs a deterministic scoring/pricing engine producing direction/probability/edge/risk, uses an OpenAI-compatible LLM strictly as an explanation layer, and reads Polymarket Gamma read-only. It writes evidence and recommendation hashes on-chain via web3.py to a deployed ReasoningRegistry contract on Arc, with no custody or order execution.

A forkable stack of Arc primitives for prediction markets and autonomous agents: MeridianMarket.sol (an LMSR AMM with fee-as-surcharge accounting and parimutuel payout, backed by 71 tests), AgentVault.sol (an agent treasury earning USYC yield on idle funds), and ResolutionOracle.sol (dual-tier Chainlink/admin resolution). It also ships a Circle Developer-Controlled Wallet plus NestJS signing/polling pattern with ERC-8004 auto-registration, a Brier-score reputation service, and an x402-style nanopayment API guard. A 12-language RSS-to-Claude pipeline drives an on-chain LMSR market factory deployed on Arc testnet.

A fork-and-run repo (AGPL-3.0, with a 90-second demo-full-cycle.ts) exposing reusable agent-to-contract modules: lib/circle-w3s.ts wraps W3S as a typed agent signer with RSA-OAEP entity-secret encryption, contract-execution polling, a USDC transfer helper, and a public-key cache; lib/cctp.ts adds a browser CCTP V2 stepper with Iris polling and source-chain switching; plus a multi-agent council orchestration template, a keyless deploy script, a Gateway proxy/balance widget, a provider-agnostic LLM call, and Kelly-sized staking. It runs an AI-settled P2P claim market end-to-end.

Three modular, independently forkable Arc primitives. An x402 facilitator for Arc provides a Fastify verification server with Redis replay-attack prevention, on-chain payment verification, REST POST /verify and /verify/batch endpoints, and a Docker self-hosting config. A parallel copy-trade executor monitors a leader wallet over WebSocket, classifies transactions, and fans out via Promise.all() to exploit Arc sub-second finality with proportional sizing, millisecond execution logging, and RPC reconnection logic. An x402 Next.js middleware exposes requirePayment() for API routes with an HTTP 402 response builder, payment-proof header parsing, automatic facilitator verification, and full TypeScript types.

Forkable end-to-end patterns spanning transaction logic, state sync, and web client. It exposes a per-second stream-accrual engine using millisecond block-timestamp offsets for dynamic React UIs, an automated split-routing contract (MicroBenefitsVault.sol splits a unified payment into HSA/Pension/Savings buckets plus a shared liquidity treasury), a decentralized risk-pooling co-op primitive, an AI-agent Viem sandbox wrapper using createWalletClient with private-key signers, and an EVM transaction-simulation wrapper for dry-runs before wallet authorization. The StreamingPayroll and MicroBenefitsVault contracts have Arc addresses and real wagmi useWriteContract calls for createStream, withdraw, deposit, and processClaim, with a requestAnimationFrame streaming UI.

NOTARY is a forkable 'Witness-to-Pay' system: a 6-agent LangGraph swarm (Claude + Groq) that researches real-world evidence including audio/video, renders graded verdicts under uncertainty for proportional payment, runs a dispute path with counter-evidence re-evaluation, and applies calibrated confidence scoring and adversarial-evidence resistance (Guardian Sentinel). It includes EIP-712 attestation signing, seven Solidity registries (Identity/Attestation/Validation/Karma/Governance/Agent/Replication), a Foundry deploy script, and an Arc RPC client (eth_sendRawTransaction, USDC Transfer-log verification against native USDC 0x3600...), plus a legal-embodiment pattern (zero-member LLC with a machine-readable operating agreement hashed on Arc). Note that demo_mode defaults on with sha256-simulated tx hashes, every ARC_*_ADDRESS in .env.example is blank, and no deployment addresses exist, so on-chain attestation and settlement are not demonstrated.

Runs as three MCP servers (payments, data, ledger) that any MCP agent can import, implementing an autonomous agent that buys priced data wholesale via x402 and resells synthesized answers at cost-plus-15%. It exposes an x402 buyer over Circle Gateway, a seller paywall that settles only when the upstream returns content, an Arc chain config documenting the 18-decimal-gas vs 6-decimal-USDC split and the USDC name() gotcha, wallet funding scripts, and a micropayment ledger keyed to Gateway batch references. A Claude tool-use loop with hard budget rails drives a market of seven real vendors (CoinGecko, SEC EDGAR, OpenAlex, Tavily), settling on Arc through the @circle-fin/x402-batching Gateway SDK.

OpenMind provides drop-in Python tools: agent/onchain/trace.py with dependency-free build_trace/canonical/trace_hash for tamper-evident reasoning hashing, and agent/onchain/arc.py, a web3.py ArcClient with anchor(hash) and transfer_usdc with 6-decimal handling. It implements a GraphRAG prediction agent that builds a custom ontology, LLM-extracts a date-bounded entity graph from Tavily news with a temporal_guard, estimates P(YES) via AWS Bedrock (Nova/Claude Converse), sizes positions with fractional Kelly under circuit-breakers, then sha256-anchors the trace on Arc via real web3 transactions with a USDC settlement.

A TypeScript orchestrator for prediction-market arbitrage on Arc. It spawns the published @gonzih/poly-scout MCP server for smart-money signals, sizes bets with deterministic Kelly criterion math, and wraps Circle sandbox wallets alongside an Arc JSON-RPC reader. The Arc JSON-RPC client and Circle Wallets bindings are intended for extraction as standalone packages but are not yet split out, so the forkable source is the orchestrator repo itself.

Oracle is an autonomous prediction-market agent that reads live Polymarket markets, estimates true probability with LLM reasoning, sizes via Kelly, and publishes signed picks on Arc Testnet through a PickLedger contract with a sha256 reasoning hash. A Next.js and viem frontend renders the pick feed and routes Polymarket V2 orders with a bytes32 builder code attached, a CCTPv2 bridge built on Circle Bridge Kit moves USDC fees to the agent treasury on Arc, and a ReputationRegistry records realized PnL. Foundry tests cover both contracts and a passkey-based Circle smart account is included.

OracleLab provides a forkable experience-marketplace stack with on-chain plumbing: a clean Solidity AgentExperienceMarket (registerAgent, listExperience, buyExperience paid in native USDC via msg.value, hasAccess verification) plus a Python library performing real web3.py contract writes (market.py), real Pinata IPFS pinning (ipfs.py), and keccak trace hashing and verification. The contract is deployed with real on-chain transactions, giving builders a reusable foundation for an agent-to-agent experience economy.

A three-tier autonomous agent network that scouts, Bayesian-judges, and attests prediction-market oracle resolutions on Arc, with several forkable primitives. AttestationVault.sol commits any off-chain AI verdict on-chain with a confidence score in BPS, an IPFS trace CID, and agent identity; a Python library provides ERC-8004 and ERC-8183 integration covering agent wallet creation, on-chain identity registration, reputation scoring, and USDC job escrow. It also ships a LangGraph plus Arc attestation pipeline (a judge_agent.py drop-in template using Claude Haiku for writing reasoning on-chain) and a USYC auto-deploy pattern where a Treasurer agent rotates idle USDC into Circle's tokenized money-market fund on balance thresholds.

A CCTP-V2 insurance/SLA layer for cross-chain agents, shipped as the standalone pact-arc-arbitrage repo (~930 lines of TypeScript on viem, Apache-2.0). The viem agent burns USDC on Arc via TokenMessengerV2.depositForBurn, polls Circle's Iris sandbox API, mints on Base Sepolia via MessageTransmitterV2.receiveMessage, then settles a Pact contract on Arc where breach equals measured attestation latency over SLA. The Pact contracts are deployed and Arcscan-verified on Arc Testnet (PactRegistry 0x60e51f2c8c162ec13c7c7234fc9490936127f01b, PactPool 0xc5d4c573828e998695b6bd5577947bc77a8f7f97, PactSettler 0xccf30140d74cc0d384800501506d50fe622ae963), exposing registerEndpoint, topUp, settleBatch, recordCallAndCapAccrual, balanceOf, a CallSettled event, and full ABIs as a register-to-settle template.

An MIT-licensed Arc-native stack combining a Foundry suite of 20+ contracts (with Halmos symbolic checks) and a ~13-service Python monorepo. The Solidity layer includes ProofOfRestraint.sol (on-chain proof of agent non-action), VisitorWitness.sol, NoTradeAlpha.sol, and TradeIntent.sol, an EIP-712 x402 PaymentAuthorization verifier with nonce-replay protection and EIP-2 low-s malleability rejection; six contracts are deployed to Arc (chain 5042002) with recorded tx hashes and a live first-restraint witness. It also ships TypeScript helpers (x402, session keys with TTL/per-trade/cumulative USDC caps, a wagmi MetaMask decimals workaround) and Python primitives including a fallback LLM client chain and a genuine 11-agent four-round debate council with Zeus/Solon vetoes recorded as on-chain restraint events.

Pharos ships a binary prediction-market CPMM (PharosMarket/PharosFactory, Solidity 0.8.24) with complete-set escrow and a proven solvency invariant (totalCollateral==outstandingYes==outstandingNo), USDC-settled on Arc, that posts a separate framework probability on-chain via updateFrameworkProb so edgeBps compares model vs crowd. It is backed by a quant pricing engine (FastAPI + pandas/scipy with point-in-time nowcasts, pillar z-scores, and shrink-to-0.5 calibration) and three Python web3 agents, creator, pricer, and oracle, that sign real Arc transactions, with the oracle resolving on official BLS/BEA/Fed data. A Next.js 14 / wagmi / viem dual-price market card surfaces crowd vs model pricing.

A slash-bonded copy-trade protocol in Solidity that Arc builders can fork. It ships PhronosRegistry and PhronosBond for staked agent identity (register an ERC-8004 identity and post a USDC bond, with fully-implemented Sharpe-decay slash math from SlashOracle), a PhronosRouter EIP-712 intent router with three on-chain policy refusers (Claude LLM judgment, macro-shift, whale-contradiction) writing Copied/Refused receipts via viem, and four EIP-712-signing TypeScript trader agents. Circle DCW signing (sign/typedData) runs with a local-key fallback, and the slash-bond, signed-intent, and on-chain-receipt core is deployed.

Plinth is a capital layer that turns any AI trading agent on Arc into a tokenized on-chain vault: agents create a vault with an immutable whitelist of approved venues, anyone deposits USDC at NAV and redeems on demand, and the agent directs capital under capability-not-custody constraints enforced directly in the Foundry-tested Solidity contracts. An independent Underwriter reads a public-chain perp venue's trade history and cryptographically reconciles the agent's reported PnL on Arc, while a TypeScript viem SDK and Circle CCTP bridge-kit integration give developers end-to-end deposit, deployment, and cross-chain settlement flows.

An MIT-licensed open marketplace where three reference LLM seeders (Gemini/DeepSeek/Qwen) author non-English Polymarket-shaped questions, bid in a real on-chain sealed-bid auction (web3.py openAuction/submitBid/settleAuction), and pass an 11-judge panel combining BLEU/COMET/MQM-LLM translation scoring with eight asyncio-run style judges. Forkable primitives include a stable submit-API JSON schema with attribution metadata, ReputationRegistry.sol (EWMA alpha=0.85 with a 100 USDC anti-Sybil stake), and BuilderFeeRouter.sol (per-attribution USDC fan-out with a 90/10 winner/treasury split), plus a polyglot_alpha.agent_sdk Python module and an external_operator_example.py. The auction, registry, judging, and fee-router are deployed on-chain.