Projects.

0ath describes a forkable Arc receipt primitive: take a claim, collect evidence, run an agent review, hash the important state, and write a public receipt on Arc Testnet, reusable for hackathon judging, grants, bounty milestones, or any agent-decision workflow needing later verifiability, plus a product flow around receipts (claim creation, back/challenge, evidence submission, agent reasoning, ArcScan verification, and a judge page distinguishing real from demo). Only planning and requirements docs and a GitHub-issue map are committed; there is no application code, no contracts, and no frontend.

A forkable Python/FastAPI portfolio agent exposing three composable primitives: a Regime Detection Module, a CoinGecko-fed multi-signal classifier weighting momentum, trend, volume, and correlation heuristics; a Goal-Based Allocation Engine with configurable profiles, drift detection, and auto-rebalance triggers; and an Arc Settlement Layer that wraps USDC transfers in a few lines via web3.py against Arc chainId 5042002 native USDC. It ships with 38 passing tests.

A blueprint for consumer payment dApps exposing four primitives: a programmatic revenue splitter (AdRevenueSplitter.sol) that locks USDC in escrow and routes basis-point splits to dynamic recipients on oracle signature verification (reusable for subscription splitters, affiliate systems, and tipping), an oracle-protected sponsored relayer wrapping the Circle DCW SDK with environment-level Entity Secrets and on-chain signature checks, a getCode() bytecode pre-flight that drops into a Supabase-backed Sandbox Mode so builders can iterate on UI and DB without MetaMask or faucets, and a sub-100ms Supabase Postgres read-cache pattern for on-chain data. The splitter performs real USDC splits gated by onlyOracle.

Aegis Market Operator is a FastAPI full-stack demo that turns market inputs into disciplined, auditable outcomes through a clear pipeline: signal, reasoning memo, a hard risk gate that outputs SCALE, OBSERVE, or DISABLE, a settlement intent, and a persistent SQLite audit trail. It ships safe-by-default with deterministic reasoning and Arc/USDC-shaped Circle Wallets and Gateway payloads, and offers an optional live Arc Testnet proof endpoint that reads chain ID and block number through the arc-canteen CLI. Every run is stored and retrievable for review.

A forkable autonomous prediction-market agent for African news on Arc, built around a custom AgbaMarket.sol supporting USDC and EURC betting and real USYC ERC-4626 invest/redeem with both the 3-param deposit/redeem signature and a buy/sell fallback plus yield distribution. Next.js cron routes drive the loop: /api/agent/scan runs Groq llama-3.3-70b to mint markets via createMarket() with tx.wait(), and /api/agent/resolve uses Tavily search plus Groq to call resolveMarket() on-chain. It offers a reusable LLM-to-contract pipeline with JSON-schema enforcement, a search-then-reason resolution pattern, and a working open-source USYC ERC-4626 vault integration on Arc.

Agentcourt is a forkable safety/decision layer for autonomous agents exposing two primitives: a policy engine offering policy-as-code with structured violation results and evidence hashing, an SDK for deciding what happens when an agent acts out of bounds; and a reusable dashboard plus contract-flow template for reputation, staking, and slashing. It ships an implemented Solidity contract and UI as the decision layer that complements USDC-movement examples.

An agent-native paid data-routing primitive on Arc: an agent sends a structured capability request and the router discovers provider services, checks manifests, quotes price, performs Arc USDC/x402-style settlement, invokes the provider, verifies the response, returns an agent_data_envelope_v1, anchors evidence hashes, and collects ERC-8004-style trust feedback. It ships a working stdin/stdout MCP-to-HTTP JSON-RPC bridge exposing five routing tools, protocol docs, a provider-agnostic skill, a packaged .mcpb scaffold, and forkable pieces for service discovery, paid invocation, provider onboarding (Provider Studio, OpenAPI import, manifests), and evidence receipts.

A forkable foundation for AI finance bots, tipping bots, and consumer payment apps on Arc. It exposes Telegram identity to wallet mapping, AI-to-on-chain transaction routing, and social USDC payment flows. The working Telegram bot parses natural-language pay, save, and tip commands via DeepSeek and sends real ERC-20 USDC transfers on Arc using the native USDC predeploy.

A forkable, modular AI-to-Web3 template for autonomous financial agents built on .NET. It exposes a reusable transaction-monitoring worker, a clean Nethereum (C#) signing service for Arc, and an event-driven streaming pattern over SignalR that other builders can adapt for their own AI-driven DeFi strategies. The backend wires a Groq LLM trading-decision flow to Nethereum signing on Arc with EF Core persistence, presented as autonomous LLM-driven trading agents.

An upgradeable USDC-staked signal-and-reputation market primitive with reusable contract and frontend patterns: UUPS-style upgradeable contracts, public signal history, market settlement evidence, agent-level reputation, visible signal IDs, watchlists, quality scores, stake-weighted sentiment, owner-based resolution, and a discovery dashboard. The contract is a real UUPS-upgradeable Foundry deployment supporting publish/resolve/autoResolve of time-bound staked signals in USDC, live on Arc at 0x4135590D1733d6A5965350A3Ca6A8232e97C8D00 with a Vite/wagmi frontend, and can be forked for prediction, trading, research, or sports-signal markets and reputation-weighted dashboards.

A forkable set of patterns for auditable AI-agent workflows on Arc, including reasoning fingerprinting, structured event-generation pipelines, multilingual ingestion, and UX patterns for transparent AI orchestration. It ships a disciplined no-fallback LLM pipeline and a trace-registry contract that anchors these workflows, giving builders product-oriented operational primitives layered on Arc.

A standalone MIT-licensed kit (https://github.com/yashishkhurana/arc-boring-vault-agent-kit) providing a model-agnostic merkle-bounded agent guardrail plus an on-chain reasoning journal for AI-managed vaults on Arc. It wraps a full Veda/BoringVault Foundry stack (BoringVault, ManagerWithMerkleVerification, Teller, Accountant, decoders) deployed to Arc with addresses pinned in config, an AgentJournal reasoning log, and an OpenAI-compatible LLM strategist (DeepSeek, with a deterministic rule-engine fallback) that selects from a merkle-allowed action menu re-verified on-chain; a keeper reads the vault's real USDC balance and broadcasts manageVaultWithMerkleVerification plus journal.record.

A working Next.js multichain portfolio application exposing reusable patterns: an Arc Testnet hub (single app with a Testnet/Mainnet toggle, Arc-first gas copy, and an RPC balance fallback in arc-balance.ts for Arc USDC), a Circle App Kit integration layer for bridge/swap/send/faucet with a CCTP flow, fee previews, scan steps and Vercel-safe API routes, a multichain portfolio feed in portfolio-wallet.ts merging Zerion and GoldRush without double-counting chains with per-chain drill-down and PnL, and an adaptive engine with regime detection, target allocations and a rebalance queue. It performs live Zerion, GoldRush/Covalent and CoinGecko reads and genuine Circle App Kit execution targeting Arc Testnet (chainId 5042002).

A forkable autonomous risk-guard system with three Hardhat contracts deployed on Arc 5042002 (per addresses.json): RiskGuardOracle.sol, a reusable on-chain verdict registry where agents write CLEAR/CAUTION/HALT verdicts for frontends to read; GuardianVault.sol, a user-controlled vault that pulls in tokens autonomously on HALT while keeping manual withdrawal; and ThreatRegistry.sol for community threat reporting with upvotes and aggregate scoring. A Claude Sonnet brain with a deterministic rule-based fallback runs five guard rules, registers ERC-8004 identity, and drives a Twilio voice/WhatsApp alert pipeline from on-chain events, with agent logs showing live cycles writing real verdict txns to Arc, plus a React dashboard.

A LangGraph prediction-market intelligence agent integrating Groq, NVIDIA, OpenAI, and Tavily, with an Arc proof transaction and an x402 trace paywall. It incorporates agent risk-management tooling and offers the full application as a forkable artifact for builders working on agentic prediction-market workflows on Arc.

AgoraLens is a forkable agent-based market-integrity pattern on Arc, exposing primitives for real-time signal ingestion via GDELT and Google News RSS, a read-only feed adapter into external prediction markets, and a MarketCourt agent architecture producing structured Bull/Bear/Judge rationale. It ships an Arc Testnet receipt registry (reason hash, market ID, signal hash, integrity score, lifecycle stage, decision) and a Ledger UI that reads receipts back from Arc RPC with tx-hash and explorer links, reusable for AI audits, market supervision, agent decision journals, and risk analysis.

A forkable repo exposing two primitives for regime-aware, on-chain agents: an AgentRegistry contract with a bytes32 agent identity and register/writeRegimeSignal/getRegimeSignal functions that any agent framework can drop in, and a FRED macro regime classifier (fred_client.py plus classifier.py) that emits structured JSON ready to wire to on-chain actions. The regime-detection module is a clean standalone Python package producing live DGS10, T10Y2Y, and VIX signals in roughly ten lines.

Agora Perp Agent is an autonomous crypto-perpetuals trading engine that streams live Hyperliquid market data, forecasts each asset with a deterministic quant core, and lets an LLM select trades while pure-Python logic handles sizing, leverage, stops, and risk gating. Every decision is hashed and anchored on Arc Testnet as an ERC-8183 job through Circle's MPC-custody wallets, producing an independently verifiable on-chain track record. It ships a live dashboard and a deep pytest suite.

A complete, forkable reference implementation of Arc's agentic-economy stack, combining ERC-8004 identity and reputation, ERC-8183 job settlement, and Circle gasless SCA wallets against a prediction-market use case with on-chain Arc interaction using native USDC and reference contracts. It adds a Groq probability-estimation pipeline, Kelly bet sizing, Polymarket CLOB integration, a real-time SSE dashboard with explorer links, and a post-expiry resolver. Builders can swap in any EVM prediction market, add data feeds, extend reputation logic, and deploy a zero-gas agent.

Three Arc primitives an AI portfolio manager can fork from chain.py: commit-then-act anchoring that embeds decision hashes in Arc calldata before executing trades for an on-chain audit trail, a regime-detection agent loop (a reusable FastAPI plus async SQLite pattern with rate limiting, WebSocket live feed, and visitor tracking), and USYC rotation logic for switching between idle USDC and the USYC tokenized money market on AI regime signals. It uses Kimi K2 / Moonshot via an OpenAI-compatible interface; decisions are anchored on Arc while the rebalancing itself is simulated.

A forkable prediction-market product already running on Arc testnet, deployed with on-chain artifacts and receipts, that other builders can fork, extend, and innovate around. It offers a working end-to-end prediction-market application on Arc as a foundation for building and growing new agentic-finance products.

Web3 Auditor Platform is an LLM-driven Solidity security analysis engine that loads contract projects, runs Slither static analysis, and pairs an analyst model with an adversarial hacker model to surface vulnerabilities. It generates and executes Foundry verification tests in an isolated workspace with an automated repair loop, ships reusable templates for common vulnerability families such as reentrancy, inflation, delegatecall, and access-control takeover, and exposes a web UI with background job execution and persisted results for pasted, multi-file, or zipped Solidity.

A forkable rotating-savings-group (ROSCA / Ajo / Esusu / Susu) coordination layer on Arc for stablecoin-native group finance with transparent contributions and trust-minimized payouts. The implementation is a clean Solidity ROSCA contract using custom errors that settles USDC pots, paired with a Foundry deploy script and a browser wallet-sign deploy and member app running against a circle address on Arc.

A FastAPI multi-agent FX broker plus MCP server exposing x402 micropayment verification against Arc USDC transactions (by reading tx receipts), a four-agent pipeline with Kelly Criterion risk sizing, and a USDC/EURC settlement flow with real-time EUR/USD rate feeds. It performs real on-chain USDC and EURC ERC-20 transfers on Arc, ships an RSI/MACD/Bollinger signal engine, deploys an AgentRegistry at 0x047445Bf2CC338D635324B8Fe286Dcc74c642789, and has 100 logged successful settlements. The MCP server interface enables agent-to-agent calls.

A governed payment gateway wrapping Circle/x402 with trust scoring, policy enforcement, and reconciliation, plus a route-scorecard engine, receipt/proof layer, reconciliation ledger, and TypeScript and Python SDKs for adding governed paid-intelligence calls to any agent in one integration. The governance plumbing (trust scorecard, policy engine, receipts, reconciliation) is implemented in TypeScript, and a genuine x402 client (@x402/fetch, @x402/evm, Circle DCW, EIP-712, targeting Arc 5042002) backs the AIsa data feed. The platform separates infrastructure from application so builders can adopt the gateway without the reference agents.

A forkable quantitative-finance stack centered on Linus, a paper-anchored knowledge database, exposing portfolio rigor primitives built on Deflated Sharpe Ratio (DSR) and Probability of Backtest Overfitting (PBO) methods. The implementation is deployed on Arc testnet with 25 deploy transactions and 73 tests, producing on-chain artifacts and receipts that back the portfolio-evaluation flows.

Apollo.Trade (github.com/TripleCapitalAI/apollo-trade) is a delta-neutral Hyperliquid carry-trade dashboard with an AI chat assistant built on OpenAI GPT-4o. The repo is forkable, but no specific reusable Arc primitives are broken out.

An autonomous portfolio agent (~1850 LOC TypeScript/Bun, 15 test files) running on a Circle SCA wallet provisioned via @circle-fin/adapter-circle-wallets, where a RedPill (OpenAI-compatible) LLM decides regime and allocation over live Coinbase BTC/ETH price and volatility, a deterministic guardrail clamps it to the mandate, and execution runs through Circle App Kit bridge (CCTP)/send plus an Aqua0 SwapVM swap before recomputing USDC NAV. It also ships a hosted MCP server exposing the agent to any MCP client (signup, set_mandate, run_tick, dashboard, market, decide, NAV tools), Arc-native USDC handling, and a USYC Teller subscribe/redeem flow.

Arcadia is a forkable, locally-hosted Arc indexer boilerplate: a substantial Go plus SvelteKit indexer and analytics platform that streams Arc L1 via Envio HyperSync and indexes blocks, transfers, FX swaps, CCTP/Gateway flows, and ERC-8004 agent and ERC-8183 job-escrow lifecycle events. Builders can fork and extend it as a ready-to-run real-time indexer with agent-economy analytics.

arc-agent-kit is a typed TypeScript toolkit that gives LLM agents a ready-made surface for transacting on Arc. It ships a viem-based SDK for USDC and EURC balances, transfers, CCTP queries, and pre-flight gas simulation, a stdio MCP server exposing 18 tools for any MCP host, CLIs, and Anthropic and OpenAI function-call schemas with a dispatcher. It includes an x402 paid-fetch client and an on-chain recurring-payments escrow contract deployed on Arc testnet for trustless subscription create, charge, cancel, and withdraw.