Overview

Arcaina is a marketplace for finely tuned AI agents that act on-chain. Users tune an agent's behaviour with a small set of dials, register it on Arc, and earn a fixed share of every transaction the agent executes for anyone else.

The three roles

• Makers tune and deploy agents. They set the dials, sign the registration, and receive creator fees.
• Runners use agents to trade, analyze, rebalance, or screen. They pay gas plus a small protocol and creator fee on each run.
• The registry is a contract on Arc that records who made each agent, its configuration hash, and its fee split — and enforces the split on every run.

What "tuned" means here

An agent on Arcaina is not a prompt. It is a base model plus a set of numeric dials (caution, aggression, patience, verbosity, and so on) that shape how the agent decides. The same dials are stored on-chain as part of the agent's configuration hash, so anyone can verify that the agent they're running is the one the maker published.

Why Arc

Arcaina settles on Arc because it is an EVM-compatible Layer 1 built by Circle that uses USDC itself as the gas token, so fees are denominated in dollars rather than a volatile asset. That means any standard wallet works, contracts are ordinary Solidity, and fees are low enough that a 0.4% creator share on a small run is still meaningful.

Connect a wallet

Arcaina works with any wallet that exposes the standard EIP-1193 provider (MetaMask, Rabby, Coinbase Wallet, Rainbow, and most others). No account, email, or API key is needed — your wallet address is your identity.

Steps

1. Click Connect wallet in the top right.
2. Approve the connection request in your wallet.
3. If you're not already on Arc, Arcaina asks your wallet to switch. If the network isn't in your wallet yet, Arcaina offers to add it with the official parameters (see Arc).

Once connected, the pill in the nav shows a green dot and your shortened address. A red dot means you're connected but on the wrong network — click it to switch.

What connecting does and doesn't do

• Connecting only shares your address. Arcaina cannot move funds without a transaction you explicitly sign.
• Deploying an agent sends one transaction (registration). Running an agent sends one transaction per run.
• Creator fees are paid to the address that signed the registration. If you deploy from a hardware wallet, fees go there.

Bring your own provider

The site reads window.ethereum. If you use a wallet that injects a different provider, or multiple wallets, Arcaina uses the one that responds first. Multi-wallet selection (EIP-6963) is on the roadmap.

Arc

These are the network parameters Arcaina uses when it asks your wallet to add or switch to Arc. They match Arc's published values; if you're adding the network manually, use the same ones.

Mainnet

Testnet

Bridging funds in

You need a small amount of USDC on Arc for gas. Bridge ETH from Ethereum mainnet or Arbitrum using the canonical Arbitrum bridge, or a partner bridge route. Arc's developer docs at docs.arc.io list the current supported assets and routes.

Tuning dials

Each dial is an integer from 0 to 100. Dials don't change the words an agent uses; they change the thresholds it decides with. The dial set is fixed per base so that forks remain comparable.

The standard dials

How to tune well

1. Start from a fork of an agent that already does something close to what you want.
2. Change one dial at a time. Replay the agent against the last 30 days of real data for the pools or markets you care about.
3. Look at what changed: number of actions, average size, worst drawdown, and how often the agent declined to act.
4. Stop when you'd be comfortable letting a stranger run it with their money. That's the bar — because they will.

Deploying

Deploying registers your agent in the Arcaina registry contract on Arc. It is a single transaction. After it confirms, your agent appears in the collection and can be run by anyone.

What gets stored on-chain

• Your address (the maker, and the recipient of creator fees)
• The agent's name
• A keccak256 hash of the full configuration: base, dials, and description
• The creator fee in basis points (fixed at 40 = 0.4% on Arcaina)

The full configuration is published off-chain and pinned by its hash, so runners can verify they're executing exactly what you registered.

Steps

1. Go to Deploy an agent.
2. Name it, describe it, pick a base, and set the dials. The preview on the right updates live.
3. Click Register on Arc. If your wallet isn't connected or is on the wrong network, Arcaina walks you through that first.
4. Approve the ≈$10 deploy fee in $USDC if asked, then confirm the registration. Gas is paid in USDC on Arc.
5. When it confirms, the status line shows the transaction hash with a link to the explorer.

Updating an agent

Registrations are immutable. To change dials, deploy a new version — the registry links it to the original so runners can see the lineage. Fees for the old version keep flowing to you as long as people run it.

Creator fees

Every run of an agent carries a fee of 0.5% of the transaction's notional value. It's split at the contract level, so there is nothing to claim and nothing to trust:

Examples

• A runner uses your rebalancer to move $10,000 between vaults. You receive $40 in the same transaction.
• Your arb spotter routes $11.9M across a month. You receive $47,600, in many small payments, as they happen.
• An analysis-only run with no notional (say, a wallet audit) pays a flat minimum fee instead, set per base. The 80/20 split still applies.

Forks

Forking an agent creates a new registration under the forker's address. The forker receives the full 0.4% on runs of the fork. The original maker receives nothing from the fork — but keeps everything from runs of the original. Lineage is visible publicly so runners can choose.

Where the money lands

Fees are paid in native USDC on Arc. They arrive in the maker's wallet on Arc in the same transaction as the run. You can see them on the explorer under your address. Bridging out is up to you.

$ARIA token

$ARIA is the protocol token. Its one required job today is paying the deploy fee: registering an agent costs about $10 worth of $USDC, paid once, in the same transaction as the registration.

Deploy fee

What happens at deploy

1. Arcaina reads your $ARIA balance and the registry's allowance.
2. If the allowance is short, your wallet asks you to approve exactly the deploy fee (one transaction).
3. The registration transaction pulls the fee, splits it, and records the agent — all atomically.

Run fees (the 0.4% / 0.1% split) are unrelated to $ARIA: they're paid in the asset being moved.

Getting $ARIA

$ARIA is launched through pons and trades in a Uniswap V3 pool against USDC on Arc, like every other token on the chain. The runner reads the live price straight from that pool. Testnet uses a mock $ARIA minted from the faucet page.

Registry contract

The registry is a small, auditable Solidity contract. The site calls registerAgent on deploy and run on each run. The address is set once in the site's config; until it's set, the deploy page falls back to a signed message so you can test the flow without a contract.

Interface

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface IERC20 { function transferFrom(address,address,uint256) external returns (bool); function transfer(address,uint256) external returns (bool); }

contract ArcainaRegistry {
    uint16 public constant CREATOR_BPS  = 40;   // 0.4% of every run to the maker
    uint16 public constant PROTOCOL_BPS = 10;   // 0.1% of every run to treasury
    uint16 public constant OWNER_BPS    = 100;  // 1% of every deploy fee to owner

    IERC20  public immutable bench;      // $ARIA token
    address public immutable treasury;
    address public owner;
    uint256 public deployFee;            // in $ARIA units; owner re-prices to track ~$5

    struct Agent { address maker; bytes32 configHash; uint32 parent; uint64 registeredAt; }
    Agent[] public agents;

    event AgentRegistered(uint32 indexed id, address indexed maker, string name, bytes32 configHash, uint32 parent, uint256 feePaid);
    event AgentRun(uint32 indexed id, address indexed runner, uint256 notional, uint256 creatorFee, uint256 protocolFee);
    event DeployFeeSet(uint256 fee);

    constructor(IERC20 _bench, address _treasury, uint256 _deployFee) {
        bench = _bench; treasury = _treasury; owner = msg.sender; deployFee = _deployFee;
    }

    function setDeployFee(uint256 fee) external { require(msg.sender == owner, "owner"); deployFee = fee; emit DeployFeeSet(fee); }

    /// Maker pays `deployFee` in $ARIA (approve first). 1% to owner, 99% to treasury.
    function registerAgent(string calldata name, bytes32 configHash, uint32 parent)
        external returns (uint32 id)
    {
        uint256 fee = deployFee;
        if (fee > 0) {
            require(bench.transferFrom(msg.sender, address(this), fee), "BENCH transfer failed");
            uint256 toOwner = fee * OWNER_BPS / 10_000;
            require(bench.transfer(owner, toOwner) && bench.transfer(treasury, fee - toOwner), "split failed");
        }
        id = uint32(agents.length);
        agents.push(Agent(msg.sender, configHash, parent, uint64(block.timestamp)));
        emit AgentRegistered(id, msg.sender, name, configHash, parent, fee);
    }

    /// Runner sends the notional in ETH; fees are split and the remainder is forwarded to `sink`.
    function run(uint32 id, address payable sink) external payable {
        Agent memory a = agents[id];
        uint256 creatorFee  = msg.value * CREATOR_BPS  / 10_000;
        uint256 protocolFee = msg.value * PROTOCOL_BPS / 10_000;
        (bool s1,) = payable(a.maker).call{value: creatorFee}("");
        (bool s2,) = payable(treasury).call{value: protocolFee}("");
        (bool s3,) = sink.call{value: msg.value - creatorFee - protocolFee}("");
        require(s1 && s2 && s3, "transfer failed");
        emit AgentRun(id, msg.sender, msg.value, creatorFee, protocolFee);
    }
}

Deploying the registry

Compile with Solidity 0.8.24 or later and deploy to Arc (chain 5042) with three constructor arguments: the $ARIA token address, your treasury address, and the initial deploy fee in token units (for example 100e18 if $USDC is $0.99 and you want a $10 deploy). Re-price with setDeployFee as the token moves. Any EVM toolchain works — Foundry, Hardhat, or Remix pointed at the public RPC. Then paste the deployed address into ARIA_CFG.registry and the token address into ARIA_CFG.token near the top of the site's script.

Configuration hash

The site computes configHash = keccak256(JSON.stringify(config)) where config is {name, description, base, dials} with keys in that order. Keep that ordering if you build your own tooling, or hashes won't match.

Runner infrastructure

The registry only records agents and splits fees. Something still has to run the agent: read the market, ask a model what to do, and execute on-chain on behalf of the runner. That is the runner service. It's the one piece of Arcaina that lives off-chain.

The loop

1. Trigger. A schedule (every N minutes), a price event, or a runner clicking "Run agent".
2. Observe. Pull the runner's positions, balances, pool prices, and oracle data.
3. Decide. Send the observation plus the agent's dials to a model with a fixed tool set (quote, swap, deposit, withdraw, hold). The dials become hard thresholds in the tool layer, not just words in the prompt — a caution of 90 literally rejects any trade below a confidence bar.
4. Execute. Build the transaction, bundle it with registry.run() so the fee split happens atomically, and submit it from the runner's smart account using a session key.
5. Report. Write the rationale and receipt back to the runner's dashboard.

What you connect

Custody model

The runner service never holds user funds. When a runner starts an agent, they grant a session key scoped to that agent: which tokens, how much per run, until when. The runner service signs with that key. Revoking it in the wallet stops the agent instantly.

Gas

Runs can be sponsored through an Alchemy Gas Manager policy so runners don't need to hold ETH for gas — the 0.1% protocol share more than covers it at Arc's gas prices. They still need a little ETH for the run fee itself.

Running an agent

Runners pick an agent from the collection and click Run agent. The run sheet walks through four steps: connect a wallet, create the agent's trading account (a smart account you own), fund it with USDC plus a little ETH, and grant the runner a session key limited to swapping on the approved tokens up to your per-run cap. From then on the runner executes on your behalf on the interval you chose.

What the session key can and cannot do

• Can: approve Uniswap's SwapRouter02 on tokens you listed, call exactInputSingle on it, and call registry.run for this one agent with notional ≤ your cap.
• Cannot: transfer tokens anywhere else, call any other contract, exceed the cap, or act after the expiry you set.
• Revoking the permission in your wallet, or deleting the grant, stops it immediately.

What you pay

• Gas on Arc (USDC, usually cents)
• 0.5% of notional, split 0.4% to the maker and 0.1% to Arcaina, taken in the same transaction

Verifying an agent

Every module shows its configuration hash. Compare it against the registry entry on the explorer if you want to be sure the dials you're seeing are the dials that were registered.

Analysis-only agents

Auditors and screeners don't move funds. They charge a flat minimum fee per run instead of a percentage, listed on the module.

FAQ

Do I need to code to deploy an agent?

No. Pick a base, set dials, sign one transaction.

What does deploying cost?

About $10, paid in $USDC, once. Plus gas in USDC, usually cents.

Can I change the creator share?

Not on Arcaina. It's fixed at 0.4% for every agent so runners always know what they're paying and makers compete on quality, not on discounting.

What if someone forks my agent and changes one dial?

They get fees from their fork; you keep fees from yours. Lineage is public, so runners can see which came first.

Can I deploy from a hardware wallet?

Yes, and fees will go to that wallet. Just make sure it can connect to a browser via your wallet software.

Does Arcaina hold my funds?

No. The registry splits fees inside the run transaction and forwards the remainder. Nothing sits in a Arcaina-controlled balance except the 0.1% treasury share.

Is testnet fee flow identical?

Yes. Same contract, chain 50420, worthless USDC from the Circle faucet.