Projects.

Intended to expose Arc payment tooling for AI agents: a bundler fallback pattern carrying both a failed Modular Wallets path with exact userop payloads and a working EOA-plus-viem fallback, a 5-line Node.js isomorphic polyfill for the Circle SDK's window.fetch dependency, an Arc testnet integration checklist documenting undocumented constraints such as maxPriorityFeePerGas at least 1 gwei, and an AI-agent plus USDC-gas pattern keeping both settlement paths pluggable. The checkout is an empty git repository with no commits or files on any branch, so none of this is present.

A forkable autonomous cross-chain portfolio manager exposing three reusable primitives: a multi-user Circle DCW orchestration pattern with per-user SSE isolation, a 3-agent LLM council (Architect/Auditor/Arbiter) running on OpenRouter over live Hyperliquid data, and a PositionRecorder Solidity contract deployed on Arc with committed address, ABI, and bytecode plus a recorder client sending real transactions to the Arc RPC. It also wires in Circle Gateway/Unified-Balance bridging and LI.FI Earn vault selection to notarize each rebalance decision on-chain.

A zero-setup, fork-ready repo (https://github.com/LingSiewWin/arc-agent-kit, 39 contract tests and 10 Python tests) adding an agent-trustability layer over Arc. Agents self-mint an ERC-8004 identity and stake their own USDC bond via AgentRegistry, BondVault (slashable stake), PerformanceOracle, and MemoryAnchor under one deploy script, with an on-chain constitution enforced at execution and ~27x RaBitQ-compressed verifiable memory. It runs live as a Colosseum arena where agents trade LONG/SHORT duels resolved on real Pyth prices (IPyth pull-oracle at 0x2880aB155794e7179c9eE2e38200202908C17B43, registry 0x8004A818), scored on profit and prompt-injection resilience, with x402 paid queries and real Arc tx hashes.

Arc Arbitrage Bot is a Rust trading engine that runs an autonomous loop of on-chain activity on Arc Testnet: USDC/EURC micro-swaps through a Uniswap-V3-style router, liquidity provision via the position manager, USDC-to-USYC deposits, MEV sandwich and backrun routines, contract deployment, and Multicall3 batched calls. A companion TypeScript service bridges USDC from Ethereum Sepolia to Arc using Circle's AppKit and CCTP V2, giving builders a working template for high-frequency stablecoin activity on Arc.

A forkable Next.js agent exposing three primitives: an AI regime-detection pipeline that reads live CoinGecko prices, calls Groq Llama-3.3-70B for regime and allocation reasoning, and emits structured allocation JSON with a full reasoning trace; real USDC ERC-20 execution via viem on Arc testnet with tx receipts, block numbers, and ArcScan links; and a CCTP burn flow against TokenMessengerV2 (approve + depositForBurn) on Arc domain 26 with Supabase transfer history. Together these form a complete fetch-reason-execute-store-display agentic loop on Arc 5042002 against canonical Circle system contracts.

ARC CIRCLE is a forkable Next.js dual-agent suite: NEXUS for token trading and PRISM for macro. It integrates Birdeye (security, holders, snipers) and DexScreener intel, OpenAI and Anthropic verdicts with a heuristic-rule fallback, a NEXUS reasoningFactors module, Arc-testnet transactions via wagmi/viem, and Circle sandbox wallet provisioning. The payArcFee/anchorDecisionPayload path provides an on-chain decision anchor that carries keccak'd decision data in calldata, settling Arc USDC fees before agent runs and publishing explainable on-chain decisions.

A forkable copy-trading protection stack of seven Arc-native primitives, with four deployed Arc contracts: CopyGuardBondVault (a payable bond vault using native msg.value with no approvals), ReportPayment (on-chain paid reports with duplicate-purchase protection), RiskOracleAdapter (separating oracle submission from the vault), and LeaderRegistry. It pairs these with an x402-style FastAPI risk worker doing deterministic scoring plus optional Claude/OpenAI/Gemini rationale, real USDC report-payment verification via web3.py reading a ReportPurchased event from a tx receipt, a viem getLogs chunked-reading event-stream frontend in Next.js/wagmi, and a Docker Compose plus Caddy deployment template.

A consumer ecosystem on Arc shipping four Next.js apps from one pnpm/Turborepo monorepo, including the exact .npmrc and packageManager pinning needed for clean Vercel deploys. It exposes a Circle AppKit plus viem USDC transfer pattern (lib/usdcTransfer.ts) tuned for Arc's native 18-decimal USDC and RPC behavior, a server-side settlement flow (api/predict/settle) using a privateKeyToAccount wallet and sendTransaction to pay users on-chain, and a conditional-payment agent (Gogo AI) that turns natural language into real USDC transfers.

A React/Vite AI-assisted code-generation layer above the raw circlefin/arc reference material, making real Claude API calls (claude-sonnet-4-20250514) with prompt composition over eight bundled Circle SKILL.md files to generate Circle/Arc integration code, optionally enriched by the Circle MCP server. It exposes three reusable primitives: a library of eight curated SKILL.md pattern files (USDC payment flows, cross-chain transfers, wallet management, contract conventions) usable as agent context, RAG chunks, or prompt grounding; a skill-grounded generation pipeline turning intent plus skill file plus live MCP context into grounded code; and multi-agent scaffolding templates that generate orchestrator/worker agent networks with USDC nanopayments wired in.

An AI-decision-provenance layer in Python/FastAPI exposing twelve Unlicense primitives, including a quant selection-bias rigor gate (Deflated Sharpe, PBO, walk-forward OOS, look-ahead audit in pure numpy) over real backtrader backtests, a provider-agnostic LLM backend factory, a Strategy Passport schema, and on-chain reasoning-trace anchoring via TracePublisher and ReasoningTraceRegistry.sol. An autonomous agent_runner reads vaults, rebalances via AMM, and anchors keccak256 traces through a real Circle DCW signer; 10+ Foundry contracts are deployed on Arc testnet with verifiable broadcast tx hashes, live at archimedes-arc.app.

A hardware-rooted agent identity primitive for Arc: a registry contract that issues an on-chain TEE-attested bytes32 agentId usable as a composable attribution slot for venues such as Polymarket builder codes or HIP-3 adapters. It pairs this with a Circle Programmable Wallet binding pattern that provisions a wallet only after valid TEE/DCAP attestation, gating wallet creation behind proof of computation. The repo ships full docs, a CLI, a prototype/production mode split, and a build explanation so it is forkable from a fresh clone.

Arcirl AI is a full-stack dApp that unifies Hyperliquid perps, Polymarket prediction markets, and on-chain smart-money wallets into one feed, then runs an LLM signal engine that streams structured BUY/SELL/HOLD calls in real time. It integrates Circle Developer-Controlled Wallets to provision ARC-TESTNET wallets and send Paymaster-sponsored gas-free transactions, and ships LeaderBond.sol, a deployed Arc contract for USDC slash-bonded copy-trading leaderboards. Builders get a working blueprint for cross-venue agent intelligence settling on Arc.

A forkable agent-commerce surface exposing an agent-identity registry with address/ABI patterns, a paid job lifecycle (create, fund, submit, approve, settle) for human-to-agent and agent-to-agent work, reusable x402 paid-access API routes with Arc-native payment verification, a proof-history data model (payload hashes, receipts, audit), A2A marketplace front-end/API patterns, and PM2-style templates for connecting external offchain bots and LLM agents. It includes a protocol SDK, an indexer, and an LLM dispute resolver, though the on-chain escrow is largely undeployed and weakly wired.

Arc Margin is a forkable policy-and-audit pattern for autonomous financial agents on Arc: an agent monitors external markets, makes a risk decision, routes it through an on-chain Arc policy contract, and surfaces a verifiable ArcScan receipt to the user. The guardrail is real and deployed on Arc testnet with on-chain artifacts and receipts; it is rule-based with no LLM, and the reusable interfaces are described only thinly.

A forkable blueprint for agentic trading on Arc: a secure agent-controlled vault pattern (CopyVault.sol) with user deposits, share accounting, agent-published allocations, on-chain decision anchoring with hashes and before/after tracking, and pluggable execution adapters, plus a LangGraph + Arc template and a Paymaster-ready UX paying gas in USDC. The FastAPI plus LangGraph backend fetches real Hyperliquid trader fills, scores leaders with a deterministic risk-scoring engine, and writes rebalance decisions on-chain to a deployed Foundry ArcMindVault via web3.py publishRebalance, with deposit/rebalance event indexing and a Next.js frontend.

A Turborepo/Next.js + viem reference library of Arc patterns where four LangGraph + OpenRouter (DeepSeek) agents reason over live Polymarket Gamma markets and coordinate via on-chain StigmergySignal/SwarmVault events with no orchestrator. It provides a browser-driven x402 client (probe to 402 to USDC.transfer to retry, no SDK or paymaster), in-browser secp256k1 session keys with budget/expiry bounds and revoke-and-sweep but no 4337 infra, a stigmergy coordination contract, and helpers for real CCTP v2 depositForBurn with Iris polling, ERC-8004 identity registration against Arc's IdentityRegistry, and sub-cent M2M nanopayments. Contracts are deployed on Arc with Arcscan links; DEMO_MODE fallbacks exist but real on-chain paths are wired.

Lightweight, reusable browser-game templates exposing a game-loop structure, score tracking, modular UI, and a clean separation between gameplay and onchain integration (wallets, leaderboards, rewards). The shipped piece is a React match-3 game with RainbowKit wallet connect that submits daily check-ins and final scores to a Leaderboard contract deployed on Arc at 0x7069faF8220313a0FB3380b115e854A90460446c via wagmi writeContract; broader onchain integration remains future work.

ArcPort is a session-based API payment runtime that lets agents pay for repeated API and model usage on Arc. It offers a charge mode for one-off calls using EIP-3009 signed authorizations through Circle Programmable Wallets and the Gateway deposit flow, and a session mode backed by an on-chain ArcStreamChannel USDC payment-channel contract where an agent opens a bounded budget, authorizes calls with EIP-712 cumulative vouchers, then closes once and is refunded the remainder. It includes a paid Gemini inference endpoint, a copyable arcOSS starter kit with client and session policies, a wagmi/Next reference client, and reproducible on-chain proof artifacts.

A deployed agent-accountability substrate on Arc testnet with on-chain artifacts and receipts, separating an agent's Execution (Hot) Path from its Validation (Cold) Path; the agents are deterministic with no AI. It exposes an Intent Firewall (S3IntentFirewall.sol, a stateless gatekeeper proxy doing sub-second risk validation before submission), a Slash-Bonded Escrow Courthouse (S3EscrowCourthouse.sol, dual-precision 18-decimal-gas/6-decimal-token M2M settlement with USDC performance bonds), a Forensic Trace Evaluator that indexes/hashes/validates off-chain JSON reasoning traces and triggers on-chain slashing, an ERC-8004 Reputation Registry (S3ReputationRegistry.sol) with time-weighted-decay credit ratings, and Circle CLI commands (circle:setup, circle:sync:identity) to bootstrap wallets and register identities.

Arc Signal Receipts (ArcAgent Pay) is a TypeScript toolkit for agentic USDC commerce on Arc. It creates canonical, signed USDC payment intents, verifies them merchant-side against chain, service, amount, and replay-protection policy, and issues deterministic SHA-256 reasoning receipts with signature and expiry checks. A settlement-batch model and dashboard snapshot track usage and revenue, and seven runnable examples span paid APIs, escrow release, reputation routing, spend policy, and subscriptions, all backed by a passing vitest suite.

A forkable copy-trading agent built on the Gemini and Circle SDKs that exposes three reusable primitives: copy_engine.mirror_agent_trade(), a proportional copy engine that resolves active followers, scales by allocation, executes via Circle DCW, logs, and notifies with no CEX dependency; evaluate_stop_losses(), a standalone poller that checks each follower's threshold against 24h market moves and auto-exits/detaches as a drop-in for any cron; and get_wallet_stats_safe(), a resilient wrapper around Circle's wallet balance and performance API safe for hot paths.

Arc Testnet USDC Bot is a lightweight Node.js and ethers v6 toolkit for moving native USDC on Arc Testnet. It provides ready-to-run scripts to check chain ID and USDC balance, send one-off transfers, schedule recurring micro-payments, and run a continuous agent loop that executes USDC transfers on an interval. An Express server adds a live dashboard with a recent-trades feed and a runtime toggle, giving developers a fast on-ramp to automated USDC payments on Arc.

Arke ships a standalone repo (github.com/patrickbdevaney/arke-primitives) with four production-deployed, composable primitives the Arc reference repos do not cover: an ERC-8004 Reputation Registry writer for autonomous self-attested skill scores, an x402-gated FastAPI intelligence feed monetizing agent output via USDC micropayments with a dashboard bypass, a Polymarket CLOB V2 trade widget building EIP-712 builder-code orders through raw window.ethereum with no wallet library, and an on-chain Brier-score self-scoring prediction oracle. It runs a multi-model forecasting council backed by an on-chain Brier/accuracy ledger, deployed on Arc testnet with on-chain receipts.

AUGUR is a forkable prediction-market intelligence agent exposing three primitives: an agentic SSE loop streaming Claude tool-use reasoning steps to a UI as a live thought log, an x402 nanopayment unlock pattern (a 402-returning endpoint auto-paid by agentFetch() for content gating), and a Circle CCTP plus Arc settlement wrapper covering the wallet create-fund-execute-settle-log flow. The polished Next.js dashboard runs a real Anthropic Claude tool-use loop, giving builders a complete agentic UI and payment template to extend.

A forkable prediction-market stack exposing a binary YES/NO Arc contract flow (create, stake, propose, dispute, finalize, claim) with a creator bond, protocol fee, dispute grace window, and a pluggable resolutionAuthority hook, wired to Arc chain 5042002 via Hardhat. It ships an 1854-line indexer/API reading Arc events for markets, stats, activity, leaderboards, and profiles, social and evidence primitives (comments, evidence links, follows), and an off-chain multi-reviewer AI resolution flow running Gemini and OpenAI with key rotation and fallback, writing public receipts settled on-chain.

A forkable corporate-treasury orchestrator exposing three primitives: dual-decimal precision scaling between Arc's 6-decimal precompiled ERC-20 layer and the 18-decimal native gas layer, production Circle DCW contract calls using createContractExecutionTransaction with explicit ABIs to invoke arbitrary custom contracts, and a three-agent event-loop (Auditor -> Compliance -> Allocator) that queries chain state, validates off-chain assets, and triggers gas-sponsored executions. It includes a 15KB Solidity vault (milestones, multisig, agent payout limits), a Circle DCW agentController.ts, and a wagmi-wired React dashboard, though the agent payment flow is a setTimeout simulation and no deployed Arc contract address is proven.

Positioned to expose three forkable Arc primitives — a USDC escrow pattern, an on-chain agent registry with reputation scoring, and a jury consensus engine — for projects needing trustless work verification or agent identity. In practice the repo contains only a frontend mockup with no contract source or jury logic, and includes a fabricated LIVE log; any novel settlement and reputation logic lives off-repo behind an opaque external address.

arc-attribution-kit (github.com/OoJae/arc-attribution-kit, MIT, demo at arc-attribution-kit.vercel.app) exposes AttributionEscrow.sol — configurable platform-fee bps, per-subject creator mapping, operator-credited multi-creator splits (e.g. 80/20), and on-demand creator withdrawals — for multi-recipient post-checkout attribution. It ships viem read/write helpers, Foundry-free solc compile/deploy scripts, a CCTP v2 sweep generator minting USDC from Polygon Amoy into the escrow, Modular Wallets passkey enrollment, Paymaster v0.8 gas sponsorship on the claim userOp, and a minimal Next.js demo dapp with /admin and /dashboard routes. Babel Markets, its first user, is a multilingual agent (Claude Sonnet via the Vercel AI SDK) that translates non-English news into Polymarket questions with on-chain builder-fee attribution on Arc.

Arc App Kit plugins (github.com/Bagwork-fun/arc-plugins) wrap Circle App Kit for three agent runtimes — ElizaOS, Hermes, and OpenClaw — each exposing the same 16 natural-language tools for bridge, swap, send, earn, and unified balance, so new Circle chains and features land across all three at once. The deployed Arc testnet stack pairs a Gnosis-CTF conditional-token market with an AMM, Chainlink-CRE/Gemini resolution, and a working M-Pesa/Paystack fiat on-ramp, backed by on-chain artifacts and receipts.

A forkable autonomous AI investment committee on Arc where four fixed-personality agents debate, vote by majority consensus, and execute treasury actions in USDC. It exposes a multi-agent debate engine (debate-orchestrator.js) portable to trading, DAO governance, prediction markets, or moderation, a real-time SSE pipeline streaming agent reasoning token-by-token, Circle-powered USDC micro-payment gating (payment.js) for premium actions, and a minimal Viem-based Arc treasury execution layer, packaged as a full-stack React, Express, and Arc-integration app. Agents Apollo, Cassandra, and Sentinel make real Anthropic Claude calls with distinct prompts on real CoinGecko data, rendered in a 3D senate UI.