Arcane

Arcane is an agentic treasury protection protocol for autonomous AI agents on Arc. Agents monitor their USDC runway, inference-cost risk, and oracle signals, then autonomously buy mission coverage and claim payouts when compute costs spike.

The hackathon MVP focuses on a clear survival demo: an unprotected agent runs out of funds during a cost shock, while an Arcane-protected agent uses USDC coverage to finish its mission.

Why Arcane

Autonomous agents increasingly depend on paid services: LLM inference, APIs, model routers, data feeds, and onchain execution. If those costs rise suddenly, an agent with a fixed USDC budget can become insolvent before completing its task.

Arcane gives agents a simple risk-management primitive:

• Monitor mission budget and inference-cost signals.
• Pay small USDC fees to services such as oracles or risk agents.
• Buy coverage for a mission when projected cost risk is high.
• Claim an onchain payout when the oracle reports a covered cost shock.
• Continue execution without human intervention.

Hackathon Tracks

Arcane is designed primarily for the Agentic Economy track:

• Agents have clear decision logic tied to real signals.
• Agents autonomously spend USDC from their own wallet.
• Agents can use nanopayments for oracle, risk-scoring, and service queries.
• Settlement and payouts are USDC-denominated.

Arcane can also fit the DeFi track as stablecoin-native, conditional risk coverage with onchain settlement.

MVP Demo Flow

1. A mission starts with two agents:
   • Unhedged Agent: runs without coverage.
   • Arcane Agent: monitors risk and can buy coverage.
2. The oracle publishes a normal inference cost.
3. The Arcane Agent calculates its ICaR score, short for Inference-Cost-at-Risk.
4. If the projected mission cost exceeds its USDC runway, the agent buys a policy.
5. A Chaos Event raises the inference cost.
6. The Unhedged Agent becomes insolvent.
7. The Arcane Agent claims a payout from the coverage pool.
8. The Arcane Agent completes the mission.

Core Concepts

Agent Runway

The amount of time or work an agent can still afford with its current USDC balance.

ICaR

Inference-Cost-at-Risk. A demo risk score that estimates whether a mission could fail if inference or service costs rise.

Policy

A mission-specific coverage agreement bought by an agent.

Premium

The USDC amount paid by the agent to buy coverage.

Protected Threshold

The cost level above which a policy becomes claimable.

Coverage Amount

The maximum USDC payout the policy can provide.

Payout

The USDC amount paid from the liquidity pool to the protected agent when the oracle reports a covered cost shock.

Planned Architecture

apps/
  web/          Next.js dashboard for the demo and product UI
  api/          Private backend for agent logic, oracle actions, Circle integration, and logs

contracts/      Solidity contracts for policies, pool liquidity, oracle updates, and payouts

packages/
  shared/       Optional shared TypeScript types and constants

Current Stack

Frontend

• Next.js
• React
• TypeScript
• Tailwind CSS
• shadcn/ui
• Base UI preset
• lucide-react icons
• Recharts for dashboard charts

Backend

Planned:

• Node.js / TypeScript API
• Agent simulation and mission runner
• Oracle service
• Circle wallet integration
• Demo event log

Smart Contracts

Planned:

• Solidity
• Hardhat for Windows-first development
• USDC or mock USDC for local/testnet demos
• Policy purchase, liquidity deposit, oracle update, and payout claim flows

Network and Payments

Planned:

• Arc L1 / Arc testnet
• USDC-denominated operations
• Circle Wallets
• Circle developer platform
• Nanopayments for agent-to-service interactions where possible

Dashboard Sections

The product UI is designed as an operational dashboard, not a landing page.

• Overview: main demo state, agent status, risk, coverage, and actions.
• Agents: agent wallets, balances, mission status, and autonomous decisions.
• Risk: ICaR score, inference cost, projected mission cost, and runway.
• Policies: active and historical mission coverage policies.
• Liquidity: coverage pool balance, LP deposits, premiums, and payouts.
• USDC Flows: agent-to-oracle, agent-to-pool, and pool-to-agent payments.
• Oracles: published inference cost, latest update, and Chaos Event controls.
• Transactions: onchain actions and explorer links.
• Alerts: risk, chaos, claimable policy, and payout events.
• Settings: network, contract addresses, oracle wallet, and demo mode.

Local Development

The current frontend app lives in apps/web.

cd C:\Proyectos\Arcane\apps\web
npm install
npm run dev

Open:

http://localhost:3000

Roadmap

Phase 1: Dashboard MVP

• Build the dark shadcn/ui dashboard.
• Add mock state for agents, policies, oracle data, USDC flows, and transactions.
• Implement demo actions: Run Mission, Trigger Chaos, Auto Claim, and Claim Payout.

Phase 2: Agent and Oracle Simulation

• Add a backend mission runner.
• Implement risk decision logic.
• Add oracle endpoints for current cost and chaos updates.
• Persist a demo decision log.

Phase 3: Smart Contracts

• Create the policy and liquidity pool contracts.
• Add mock USDC for local development.
• Implement premium payment, policy creation, oracle updates, and payout claims.
• Add tests for the main mission-survival flow.

Phase 4: Circle and Arc Integration

• Connect agent wallets through Circle.
• Deploy contracts to Arc testnet.
• Replace mock data with contract reads and transaction events.
• Add explorer links for the final demo.

Phase 5: Submission Assets

• Public repository.
• Working deployed MVP.
• Three-minute pitch and demo video.
• Short deck explaining the problem, architecture, demo, and path to production.

Demo Message

Arcane shows how autonomous agents can manage treasury risk without human intervention. When compute costs spike, unprotected agents fail. Protected agents detect risk, buy USDC coverage, claim payouts, and survive.