Projects.

An arc-oss-builder-starter-kit for agentic commerce where policy and judging logic must run before settlement. It exposes ERC-8004 identity registration, the ERC-8183 job escrow lifecycle (create, fund, submit, complete), Circle Developer-Controlled Wallet roles for client/builder/validator, USDC 6-decimal helpers, EXECUTE/REJECT verdict fixtures, a no-chain-unless-EXECUTE guard verifying assertExecutable(verdict) runs before circleClient(), and a GitHub Actions check. A Python agent builds a compute/energy spread package and, only on EXECUTE, wraps it as an ERC-8183 job on Arc; the energy oracle is a Nebius+Opoint news-evidence classifier (DeepSeek analyst plus Qwen critic emitting p_yes receipts). The README documents the full on-chain lifecycle with arcscan tx hashes.

Precall is a forkable agent-intelligence layer over Arc and Circle rails for USDC-bonded, accountable prediction-market calls. The Foundry PrecallRegistry is deployed on Arc 5042002 at 0x86Ad5f40b39a41607dda7d7816b2CfC2a817dF76, with real viem publish/resolve/unlock transactions, a five-agent OpenAI council gated on evidence IDs, Polymarket discovery and scoring, x402 evidence and Circle Gateway wiring, and sports selected-outcome semantics (winners, spreads, over/under). It includes a full Next.js plus Railway worker app using Supabase for state and Arc for settlement, with locked-then-unlockable reasoning.

A full-stack blueprint for consumer crypto apps on Arc combining a Next.js plus Convex prediction-market app, several Solidity markets supporting high-resolution price-range outcomes with weighted payouts and DPM early exit, a subgraph indexer, and KDE charts. It exposes a gasless proxy-wallet relayer architecture for executing Arc contracts, Web2-to-Web3 onboarding via Magic SDK (non-custodial wallets from email or social login), and cross-chain CCTP deposits using @circle-fin/app-kit and @circle-fin/bridge-kit. Note that the committed deployed-contracts file shows HBAR-symbol markets staked on a Hedera token address deployed before the hackathon.

PredictArena is a forkable reference for autonomous-agent accountability built around USDC-backed signal bonds: a SignalBondArena contract with commit/resolve/refund/slash semantics, a viem-based Arc Testnet client for server-side agent commits, USDC allowance/approval handling, risk-bounded transaction policies, and commit claims with schedule-window locks to keep side effects idempotent. It exposes public proof/readiness APIs (contract address, chain ID, wallets, balances, allowance, latest tx), run receipts of what the agent saw/skipped/committed, bonded/resolved/refunded/slashed reputation models, and a seeded Monte-Carlo decision process across an end-to-end ingestion-to-resolution flow.

A forkable open-source agent-labor network on Arc combining a multi-agent marketplace with Circle MPC and a deployed stake vault. It exposes an agent registry (capabilities, task types, pricing, endpoints, wallet identity), agent manifests with an A2A discovery profile, a SkillBook layer, policy-gated wallets that compile natural-language rules into enforced typed policies, pending-approval gating for risky actions, an ERC-8183 escrow job flow (create/fund/commit/submit/complete/pay), bonded stake, replayable reputation events, MCP and REST tools, and x402-style paid endpoints. The contracts are deployed on Arc testnet with on-chain artifacts and receipts.

Prism is an adversarial AI validation system on ERC-8004 where a Claude-family Trader agent generates structured trading reasoning and a separate GPT-family Sentinel agent challenges every claim, producing a public report with an issue ledger, capital gate, and evidence provenance receipts. The Sentinel runs as an x402-protected FastMCP service that any agent can call for 0.01 USDC, with Exa MCP URL-verified evidence, IPFS-pinned traces, on-chain ERC-8004 anchoring via Circle Developer-Controlled Wallets, and a dashboard, CLI, docs site, and Polymarket gateway across the stack.

A reference implementation for Arc-native prediction-market infrastructure, offered as a forkable repo, deployed on Arc testnet with on-chain artifacts and receipts. It exposes MarketFactory-based creation of independent markets, YES/NO market contracts with USDC-style settlement, wallet-based buy/sell-back/portfolio/claim flows, resolver and admin workflows for testnet resolution, external signal curation that spins up separate Arc-native markets, frontend patterns for Arc Testnet wallet connection and faucet guidance, and deployment scripts with ABI exports and demo-ready config. It is a plain binary prediction market with no AI layer.

An autonomous builder-funding stack exposing the AI-to-payment-to-on-chain-execution-to-social-trading lifecycle as reusable primitives: nanopayment middleware, agent auth, agent-activity schemas, reasoning traces, Circle-powered execution pipelines, and copy-trading subscription APIs, organized around Scout/Underwriter/Verifier/Executor roles. It includes UUPS-upgradeable Solidity contracts (BuilderCreditCore with backProject/pledgePrize/distributePrize, plus HackathonRegistry) deployed on Arc testnet, @circle-fin/developer-controlled-wallets SDK integration, and x402 EIP-3009 TransferWithAuthorization nanopayment middleware that verifies nonces against Arc RPC, with the agent suite submitting contractExecution transactions via Circle wallets.

A pay-per-unlock reasoning-trace marketplace on Arc, forkable as five MIT-licensed, dependency-light Solidity components: UnlockMarket.sol (USDC paywall), TraceLog.sol (timestamped author/content-hash event log at roughly $0.01 per emit), and DevUSDC.sol (an EIP-3009 transferWithAuthorization reference). It also ships a read-only serverless Arc RPC proxy with allow-list, body-size, batch, and rate limits, and a nonce-bound on-chain-gated paywall API plus CLI harness covering the full buy-to-unlock-to-sign-to-consume flow. Four contracts are deployed and verified on Arc testnet.

A pythia-arc-kit package exposing hash_decision() and pin_trace_to_arc() as standalone Python functions, a single-file arc_service.py that delivers drop-in Arc attestation in around 20 lines (also usable as a CLI with --pin --hash), and a wagmi/viem arc-pin-button frontend component for reading and verifying pinned traces. It ships an automated pin-on-decision flow driven by a competitive Bull/Bear LangGraph swarm, anchoring decision traces on-chain.

Four MIT-licensed, self-contained Arc primitives depending only on Arc Testnet and Circle public endpoints: a Merkle-anchored append-only audit registry (ReceiptRegistryV2.sol plus agent/merkle.py) that commits and proves inclusion with roughly 200-byte proofs and is live and verified on ArcScan at 0x27d93c52fea923f956345af27f61d7bf47f0c4c1, x402 v2 paywall middleware for FastAPI and MCP doing per-call USDC monetization over EIP-3009 with a swappable Circle Gateway facilitator, headless Circle wallet provisioning via RSA-OAEP entity-secret encryption, and a canonical-JSON SHA-256 byte-verifier. Three contracts are deployed with a working reasoning-receipt oracle over Polymarket and Kalshi and around 4,500 receipts recorded.

regimeshift ships two MIT-licensed standalone repos, production-tested on mainnet. arc-x402-facilitator-failover (~250 LOC) is a drop-in FallbackFacilitatorClient implementing the x402 SDK's FacilitatorClient protocol to add transparent CDP plus self-hosted failover (validated sub-10ms cutover) with a reference FastAPI facilitator. regimeshift-clearinghouse provides InterAgentRepoV4 Solidity (Foundry-tested across three audit rounds): EIP-712 signed-quote escrow with an off-chain RFQ matcher pairing lender/borrower intents, Chainlink liquidation, and an Aave-style default waterfall. A companion regimeshift-agent-starter adds a four-role agent template, and the chain-agnostic wrapper ports cleanly to Arc.

A full-stack reference app modeling human work as an agent-addressable on-chain resource, with a USDC escrow Solidity contract (create/accept/submit-proof/confirm/cancel/dispute/auto-release, arbiter, fees, reentrancy guards) deployed to Arc. It pairs an x402 paid-API layer with the Arc escrow to separate API monetization from labor payout, and includes an agent-facing API, Prisma metadata, a wallet integration, a dashboard, and a viem-based AI-agent flow that funds escrow from its own wallet.

A merchant-reputation layer that answers whether you should pay a counterparty before paying USDC, packaged as a pnpm monorepo with four primitives usable today: @repute/sdk (await repute.score(addr)), @repute/cli (repute check 0x...), @repute/mcp (a Model Context Protocol server for Claude Code), and a REST /score API. A working scoring engine (SQLite, weighted reliability/latency/price minus a fraud penalty) feeds Arc-native scores derived from on-chain receipts, backed by a viem Arc-testnet (5042002) USDC Transfer-event watcher and merchant/buyer agents implementing x402 (402 plus X-Payment-Proof) with real Circle Developer-Controlled-Wallet USDC transfers. The default mode is simulate, so the headline fraud agents and trust-gap figures use synthetic addresses and faked tx hashes unless real on-chain mode is enabled.

Risk Receipt Agent is a pre-execution risk gate for autonomous market agents on Arc. A deterministic, explainable engine classifies any proposed trade, allocation, or prediction-market bet as APPROVE, REDUCE, or BLOCK based on leverage, position size, stop-loss, and probability edge, then canonicalizes the decision, keccak256-hashes it, and records it to a RiskReceiptRegistry Solidity contract on Arc Testnet. A separate executor can verify the on-chain receipt before acting. The Next.js app, viem integration, contract, deploy script, and Vitest plus Hardhat test suites are all included.

A forkable reference for multi-language, on-chain AI agents on Arc testnet, where the repo itself supplies the primitives. It includes a multi-model agent router (base_agent.py) with language-specific prompting and automatic fallback, a three-file IPFS-plus-Arc accountability loop (hasher.py, ipfs_pinner.py, arc_recorder.py) that makes agent output verifiable and financially bonded, an AdalFlow text-grad prompt-optimization implementation with auto-logged JSONL training data, and an x402 pay-per-call pattern in the Next.js App Router. Regional agents reason in native languages and write traces to an on-chain registry, with deployed artifacts and receipts.

An MIT-licensed Next.js monorepo built around RugaMarket.sol, a complete prediction-market contract with pooled USDC YES/NO betting, proportional payouts, a 2% accruedPlatformFees protocol fee, and owner-controlled on-chain resolution, generic enough to fork for any binary market. It pairs this with a multi-source signal pipeline normalizing RugCheck, DexScreener, GoPlusSecurity, and GitHub-commit inputs into a shared RawSignal type, a Groq/Llama-3.3-70B validation layer with confidence thresholds, an agent-wallet pattern that signs/broadcasts createMarket and bet transactions server-side via an ethers Wallet on Arc, and GitHub Actions/Vercel cron templates (5-minute scan, daily resolve).

A forkable repo whose primary working component is real LLM market analysis. An on-chain receipt contract is present in the code but is undeployed and unproven, and the specific reusable primitives beyond the LLM analysis layer are not described.

A derivatives-focused open-source perp DEX reference on Arc, published at github.com/JagritGumber/arc-perp-reference (MIT, project name Tangent). It ships three source-verified contracts live on Arc Testnet (AccountManager, USDCVault, MarketRegistry) with a proof-of-life registerAccount() tx, ~50 Foundry tests plus invariant fuzzing, green CI, three ADRs, and a 53KB architecture doc. Reusable primitives include permissionless EOA account registration without custody binding, a per-account USDC vault with margin hooks, an admin-curated market registry with a pluggable IPriceFeed oracle adapter, a canonical EIP-712 "Tangent v1" Order schema with frozen typehash, and a batched end-of-block settlement pattern. A Rust tangent-sdk crate provides the canonical EIP-712 Order types.

An Arc agent toolkit centered on MirrorRouter, a policy-controlled USDC delegation router with no-cascade execution so one follower can copy a trade while another blocks it in the same transaction, emitting MirrorReceipt and PositionClosed events as canonical indexable receipts for computing copy/blocked rates, reputation, and PnL from chain logs alone. It adds SourceRegistry (an ERC-8004-friendly source-agent identity/strategy/fee registry), PilotAttestor for anchoring a SHA-256 decision hash before capital moves, and three agent APIs returning live receipts, reasoning packets, and ready-to-sign calldata. Deployed on Arc testnet with per-follower on-chain slippage-refusal receipts and 30 wallets using sponsored UserOps.

SignalArc is a forkable bilingual Next.js platform where agents submit natural-language market observations that are parsed into YES/NO signals and rewarded. It ships a DeepSeek tool-call signal parser and a paper-trading engine with reward-split accounting, persisting messages and trades to JSON storage, providing a complete reference for signal-driven, reward-based agent markets.

SignalForge is a Reasoning-as-a-Service prediction-market agent that scans Polymarket markets and news, analyzes each with an AI gateway to produce probability estimates with confidence and key factors, and sizes positions with the Kelly criterion. Every reasoning trace is hashed and anchored on Arc Testnet via web3.py, and subscribers unlock signals through Circle x402 nanopayments settled with a single EIP-712 authorization through Circle Gateway. A FastAPI backend pairs with a Next.js dashboard featuring a live agent-activity terminal, giving developers a complete monetized-signal stack on Arc.

A forkable signal-market system built around agents discovering and spinning up new markets, then flipping them as they gain traction. The core is a 218-line SignalMarketFactory.sol using Arc native USDC via msg.value, with createSignalMarket, upvoteMarket, addSoftCommitment, referrals, and automatic graduation, paired with a Next.js/wagmi/viem/RainbowKit frontend, a Supabase indexer, and live Polymarket Gamma duplicate-discovery so builders can compose discovery, liquidity, and market creation on Arc.

SignalPay is a forkable marketplace where agents pay per API call in USDC over x402, exposing a drop-in x402 FastAPI middleware for HTTP 402 gating on any endpoint, an ERC-8004 reputation integration for on-chain agent identity, and an eight-node LangGraph buyer-agent template handling discovery, payment signing, and signal consumption. A Foundry SignalRegistry is deployed on Arc 5042002 at 0xEB917D183dDB7FdC1883da14dC64b8d20a77e55d, with a real x402 flow (402, EIP-3009 sign, retry) using local EIP-712 signature recovery, a Circle facilitator settle that never fabricates receipts, four server-side spend-governance gates, on-chain ERC-8004 ReputationRegistry writes, live data from Pyth, DefiLlama, and Arc RPC, and per-user HMAC-derived wallets.

Signal-to-Settlement is a TypeScript treasury agent that turns structured macro and crypto signals into risk-gated actions on Arc Testnet. A signal engine scores and classifies inputs into a market regime, and a deterministic policy engine selects hold or settlement actions with explicit risk controls. The native settlement provider verifies Arc Testnet chain ID 5042002 from the RPC before signing, supports retries and confirmation timeouts, and writes a full markdown audit report for every run covering both action and inaction.

A Next.js for-hire agent wiring all four Circle tools into one financial system: a treasury-reasoning module streaming six live financial variables into a Claude sonnet-4-6 context that returns ACCEPT or DEFER decisions, a dual-role x402 setup where the same service sells gated access (income verified and settled through the Circle Gateway facilitator at gateway-api-testnet.circle.com, GatewayWalletBatched 0x0077777d...) and buys data-API access as nanopayments via @circle-fin GatewayClient, a working USYC Teller integration performing balance-triggered on-chain sweep and redeem (approve plus deposit/redeem, reading exchangeRate and annualYield), a browser-side EIP-3009 signing utility on viem, and an SSE pattern for streaming task progress. Runs on chainId 5042002 with real multichain RPC reads as task work.

STOA is a public reasoning marketplace for AI trading agents on Arc (Circle's USDC-native L1, chain 5042002), forkable as MIT-licensed, dependency-light pieces: StoaRegistry.sol (owner-gated registerAgent/publishThesis/recordFill attribution plus a reputation layer with IPFS traceCID anchors) and CharonBond.sol / CharonBondV2.sol (USDC slash-bonds where followers stakeWith an agent and an oracleKeeper proportionally liquidates above a drawdown threshold, V2 adding a MasterChef accRewardsPerStake distributor and a mocked-accounting USYC yield rotation). It ships real reusable plumbing: a Next.js-adapted Circle x402/Gateway charge-verify-settle handler (gateway.ts over @circle-fin/x402-batching) plus an EIP-3009 transferWithAuthorization signer (nanopay.ts), a Bun HTTP+WebSocket feed-server.ts, a deterministic-salt Hyperliquid agent-key derivation pattern (hl-agent-store.ts) with builder-fee approval (hl-approve-builder.ts) and connected-wallet order placement (hl-client.ts), a Python SDK with an RFC-8785-canonical publish_thesis pipeline, and a Rust Polymarket V2 builder-attributed signer. Honest about scope: Hyperliquid is live on testnet, Polymarket is blocked upstream, record_fills uses synthetic amounts, and the CCTP V2 sweeper's reward fetch and USYC rotation are mocked/dry-run.

A forkable monorepo exposing reusable pieces by file path: an x402 facilitator verifier (apps/analyzer/src/x402-verify.ts) with a replay cache, token-bucket rate limiter, and injectable VerifierClient, a 120-line TypeScript x402 reference client implementing the full 3-step flow, a Fairblock StableTrust sequential confidential-transfer pattern, a trace-redaction utility that strips financial fields before IPFS pinning, and a TracePin pattern anchoring an IPFS CID hash on Arc for a tamper-evident audit trail. It drives a multi-agent BUY/SELL/PASS loop with a working x402 facilitator deployed on Arc testnet.

Stoa Protocol is a permissionless coordination layer that lets AI agents on different chains hire each other, lock USDC in escrow, verify work, and settle on Arc. Four deployed Solidity contracts cover registration, slash-backed reputation, validator-gated settlement, and CCTP V2 hook escrow, driven by a four-agent TypeScript pipeline that detects Chainlink/Binance spreads, executes real swaps on a Base Sepolia DEX, and settles in USDC. A reputation API monetized through x402 Gateway Nanopayments and a @stoa/core SDK make it directly composable for agent builders.

An MIT-licensed repo offering three dependency-free, vendorable modules: a PolicyVault pattern (SumplusVault.sol) with a single execute(...) entrypoint that reverts on policy-hash mismatch, action-intent gating in the policy engine where emergency actions bypass cooldowns and drawdown caps but never the asset whitelist or protocol blocklist, and a provider-agnostic LLM reasoner in one OpenAI-protocol-compatible TypeScript file where decisions are deterministic and the LLM writes explanation prose. SumplusVault and supporting oracle/swap/token contracts are deployed on Arc, with a TypeScript backend whose Arsenal skill library issues real vault.execute() writes through a hash-bound policy guardrail.