Launch a token with an AI agent on Arc

What you need

• An MCP-capable agent. Claude Desktop, Claude Code, Cursor, or any agent framework that can call MCP tools over HTTP. A plain HTTP client works too — the endpoint speaks JSON-RPC 2.0.
• A wallet the agent (or you) controls with a little USDC on Arc (chain id 5042) — USDC is Arc's native gas asset, so no separate gas token is needed. The tool's gas_hint is 3.2 million gas for a plain launch and 3.6 million when you set a tax, holder sharing or links. A launch costs well under 1 USDC — createTokenV2 at ~3.2M gas is roughly 0.13 USDC at typical Arc base fees. Bring USDC to Arc via CCTP (scripts/ops/cctp_v2_convert.py if you're on the in-house stack, or any CCTP bridge). Add whatever you want to spend on an optional first buy.
• No API key. The three launchpad_* tools are open to every agent. Only account actions elsewhere on the platform need a key.

1Connect your agent to EventTrader

Point the agent at the MCP server. In Claude Desktop that is one block in claude_desktop_config.json; Claude Code takes the same server with claude mcp add. Any agent that can POST JSON-RPC can skip the config and call the endpoint directly.

{
  "mcpServers": {
    "cymetica": {
      "command": "uvx",
      "args": ["cymetica-eventtrader-mcp"]
    }
  }
}

Or, without any package, list the tools with a single request:

curl -s https://cymetica.com/mcp/v1 -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

You should see launchpad_list_tokens, launchpad_launch_token and launchpad_trade_quote in the list.

2Give the agent a wallet with gas

The agent needs a key it can sign with, and that address needs USDC on Arc — the same USDC pays gas and any dev buy, there is no separate gas token. Two common setups:

• You sign. The agent prepares the transaction and hands it to you; you sign in MetaMask or another wallet. Add the network with the chain details above if your wallet does not have it yet. Safest — the agent never holds a key.
• The agent signs. Give the agent its own hot wallet (a fresh key, funded with only what the launch needs). Fund it with USDC bridged to Arc via CCTP, or by sending from a wallet that already has USDC there. Arc's native value_wei is USDC in 18-decimal units — not the 6-decimal ERC-20 USDC you may be used to on other chains.

3Decide the token

These are the inputs the launch tool accepts. Everything is fixed at creation and cannot be edited afterwards, so decide them before step 4.

Supply is always 1,000,000,000 tokens, all of it on the bonding curve. The curve graduates to a Uniswap v3 pool with permanently locked liquidity once it has raised 10,000 USDC, and the token is then also listed on the EventTrader orderbook.

4Ask the agent to build the transaction

Hand the agent a prompt like this. The bracketed values are yours to fill in.

The equivalent raw call, if your agent speaks JSON-RPC directly:

curl -s https://cymetica.com/mcp/v1 -H 'Content-Type: application/json' -d '{
  "jsonrpc": "2.0", "id": 1, "method": "tools/call",
  "params": {
    "name": "launchpad_launch_token",
    "arguments": {
      "chain_id": 5042,
      "name": "Rocket Token", "symbol": "RKT",
      "description": "The first token my agent launched.",
      "dev_buy": 0.5,
      "creator_tax_bps": 100,
      "share_fees_with_holders": true
    }
  }
}'

The tool answers with everything the signer needs. Like every MCP tool, the payload arrives as a JSON string inside the MCP envelope — parse result.content[0].text, then read its result field:

// raw JSON-RPC reply (MCP envelope)
{ "jsonrpc": "2.0", "id": 1,
  "result": { "isError": false,
              "content": [ { "type": "text", "text": "{\"success\":true,\"tool\":\"launchpad_launch_token\",\"result\":{…},\"latency_ms\":10}" } ] } }

// result.content[0].text, parsed — the object your signer uses is its "result":
{
  "success": true,
  "tool": "launchpad_launch_token",
  "result": {
    "unsigned_transaction": {
      "chain_id": 5042,
      "to": "0xB744…e203",          // the live Arc factory — must equal factory_address in /config for chain 5042
      "value_wei": "500000000000000000", // your dev buy (0.5 USDC, 18-decimal native units); "0" with no dev buy
      "data": "0x8be3c921…",           // encoded factory call
      "gas_hint": 3600000,             // 3200000 for a plain launch, 3600000 when any option is set
      "function": "createTokenV2"      // "createToken" when no tax / sharing / links were requested
    },
    "options": { "creator_tax_bps": 100, "share_fees_with_holders": true, "socials": {}, "creator_wallet": null },
    "chain":   { "chain_id": 5042, "rpc_url": "https://rpc.mainnet.arc.io", "currency": "USDC" },
    "fees":    { "creation_fee": "0", "curve_fee_bps": 0, "creator_share_bps": 10000 }
  }
}

Claude Desktop and most agent frameworks unwrap the envelope for you. If you call the endpoint yourself, the unwrap is one line: json.loads(reply["result"]["content"][0]["text"])["result"]. The same shape applies to launchpad_list_tokens and launchpad_trade_quote.

The tool checks the live factory before encoding, so the call it returns is always one the chain will accept. If you asked for an option the current factory cannot do, you get an error code instead of a transaction that would revert (see Errors).

5Review before anyone signs

Make the agent read the transaction back to you and confirm each of these. This is the same review step the web launcher shows humans.

• to matches factory_address in /config for chain 5042.
• value_wei equals your intended dev buy and nothing more. Creation itself is free.
• options echoes the tax, holder-sharing and links you asked for. These are permanent.
• The signing wallet has enough USDC for value_wei plus gas at gas_hint.

6Sign and broadcast from your own wallet

The transaction is ordinary EVM calldata. Any signer works; the fields map one-to-one.

Fees on Arc. Blocks arrive roughly every 0.5 s and the base fee moves with EIP-1559, same as any modern L2/L1 — a legacy transaction priced at a stale eth_gasPrice can still be rejected with max fee per gas less than block base fee if you fetch it too early. Unlike Robinhood Chain, priority tips on Arc are not zero: don't hardcode maxPriorityFeePerGas — use the node's suggested priority fee (eth_maxPriorityFeePerGas, or w3.eth.max_priority_fee in web3.py) and add the usual ~25% headroom to the base fee. Budget gas_hint × maxFeePerGas + value — the node refuses the send if the wallet cannot cover that maximum.

# Python (web3.py) — the agent runs this with ITS key, never with yours
import json
from web3 import Web3
tx_meta = json.loads(reply["result"]["content"][0]["text"])["result"]   # unwrap the MCP envelope
w3 = Web3(Web3.HTTPProvider(tx_meta["chain"]["rpc_url"]))
acct = w3.eth.account.from_key(AGENT_PRIVATE_KEY)      # from the agent's env, not the prompt
utx = tx_meta["unsigned_transaction"]
base_fee = w3.eth.get_block("latest")["baseFeePerGas"]
tip = w3.eth.max_priority_fee                          # Arc: tips are NOT zero — ask the node
max_fee = (base_fee + tip) * 5 // 4                     # +25% headroom; charged at base fee + tip
need = utx["gas_hint"] * max_fee + int(utx["value_wei"])
assert w3.eth.get_balance(acct.address) >= need, "top up the wallet first"
tx = {
    "chainId": utx["chain_id"], "to": utx["to"], "data": utx["data"],
    "value": int(utx["value_wei"]), "gas": utx["gas_hint"],
    "nonce": w3.eth.get_transaction_count(acct.address),
    "maxFeePerGas": max_fee, "maxPriorityFeePerGas": tip, "type": 2,
}
signed = acct.sign_transaction(tx)
raw = getattr(signed, "raw_transaction", None) or signed.rawTransaction   # web3.py 7 / 6
tx_hash = w3.eth.send_raw_transaction(raw)
receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
print(receipt.status, tx_hash.hex())

// JavaScript (ethers v6) — MetaMask or any browser wallet
const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();
const utx = res.unsigned_transaction;                       // res = parsed tool result (see step 4)
const fee = await provider.getFeeData();                    // Arc: use the node's suggested tip, not 0
const tx = await signer.sendTransaction({
  to: utx.to, data: utx.data, value: BigInt(utx.value_wei), gasLimit: utx.gas_hint,
  maxFeePerGas: fee.maxFeePerGas, maxPriorityFeePerGas: fee.maxPriorityFeePerGas,
});
const receipt = await tx.wait();

If you are signing by hand, tell the agent to stop after step 5 and paste the to, data and value fields into your wallet's raw-transaction screen, or let the web launcher at /launchpad/arc do the same thing with a click.

7Verify the launch

• On-chain: the receipt's LaunchCreated event carries your token and bonding-curve addresses. Circle's own explorer (explorer.arc.io) is behind an access gate until Circle opens it to the public — until then, the token page and the API below are the way to verify a launch. If you have chain access separately, decode it yourself with the signature below.
• Direct link: the token's own page is https://cymetica.com/launchpad/arc/token/<token address> — it works the second the tx is mined (it reads the token, curve and factory contracts live) and shows every piece of metadata the launch wrote on-chain, the indexed stats, trades, holders and a Buy/Sell box. Share that link.
• On EventTrader: within about 30 seconds the token appears at GET /api/v1/launchpad/onchain/tokens?chain_id=5042&creator=<your wallet> (each row carries its page_url), in the agent tool launchpad_list_tokens, on the launch page and the screener.

// Event emitted by the factory (identical on every factory generation)
event LaunchCreated(address indexed token, address indexed curve, address indexed creator, string name, string symbol)
// topics[0] = keccak256("LaunchCreated(address,address,address,string,string)")
//           = 0x0b6f3e5d73693a196bb5efee504ff46042d1036f826b445548a5e56225faec1f
// topics[1] = token, topics[2] = bonding curve, topics[3] = your wallet; data = (name, symbol)

# Python: pick the factory log out of the receipt
LAUNCH_TOPIC = "0x0b6f3e5d73693a196bb5efee504ff46042d1036f826b445548a5e56225faec1f"
log = next(l for l in receipt["logs"] if l["topics"][0].hex().lower().removeprefix("0x") == LAUNCH_TOPIC[2:])
token = "0x" + log["topics"][1].hex()[-40:]
curve = "0x" + log["topics"][2].hex()[-40:]

Anti-snipe: for the first 40 blocks every wallet, yours included, is capped at 2% of supply. A dev buy larger than the cap is trimmed to it, not rejected.

8Earn and claim

Arc launches are platform-fee-free: there is no curve trading fee and no 80/20 split. The creator keeps 100% of the locked pool's LP fees after graduation, plus any creator tax you set on the curve.

• Creator fees on the curve: your creator tax (if any) accrues via claimCreatorFees() on your bonding-curve contract, or use the Claim button on your token card at /launchpad/arc while connected as the creator.
• LP fees after graduation: collectFees(lpTokenId) on the liquidity locker (address in /config), also wired to the same Claim button — 100% is yours, nothing is taken by the platform.
• If you chose holder sharing: those fees flow to stakers instead; you earn by staking your own tokens like anyone else.

9Let the agent trade

launchpad_trade_quote returns an on-chain quote plus the unsigned buy or sell transaction for any live curve, yours or anyone else's. Same pattern: the agent quotes, you or its wallet sign.

{"name": "launchpad_trade_quote",
 "arguments": {"token_address": "0x…", "side": "buy", "amount": 0.05, "slippage_bps": 100}}

Before trading someone else's launch, have the agent run the token through the screener: holder concentration and creator-share flags catch the obvious rugs.

Error codes the tool can return

EventTrader is an independent platform built on Arc, a public blockchain developed by Circle, and is not affiliated with, sponsored by, or endorsed by Circle Internet Group, Inc. Launching and trading tokens involves real money and real risk; nothing on this page is financial advice.

Open the launcher → AI agents for beginners Launchpad screener