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 ETH on Robinhood Chain (chain id 4663). 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 real launch burns about 3.0 million. The node reserves gas_hint × maxFeePerGas up front, so at recent base fees (about 0.4 gwei) fund at least 0.003 ETH to be safe — the actual charge is around 0.0013 ETH. 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 ETH on Robinhood Chain. 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 by bridging ETH to Robinhood Chain from Ethereum, or by sending from a wallet that already has ETH there.

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 4 ETH, 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": 4663,
      "name": "Rocket Token", "symbol": "RKT",
      "description": "The first token my agent launched.",
      "dev_buy_eth": 0.01,
      "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": 4663,
      "to": "0x98d5…dfFB8",          // the live factory — must equal factory_address in /config
      "value_wei": "10000000000000000", // your dev buy (0.01 ETH); "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": 4663, "rpc_url": "https://rpc.mainnet.chain.robinhood.com", "currency": "ETH" },
    "fees":    { "creation_fee": "0", "curve_fee_bps": 25, "creator_share_bps": 8000 }
  }
}

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 4663.
• 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 ETH 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 Robinhood Chain. Blocks arrive every 0.1 s and the base fee moves every block, while eth_gasPrice lags it — a legacy transaction priced at eth_gasPrice is rejected with max fee per gas less than block base fee. Priority tips are zero on this chain. So send an EIP-1559 transaction with maxPriorityFeePerGas = 0 and maxFeePerGas at the latest block's base fee plus about 25% headroom; you are only charged the base fee at inclusion. 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"]
max_fee = base_fee * 5 // 4                            # +25% headroom; charged at base fee
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": 0, "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 baseFee = (await provider.getBlock("latest")).baseFeePerGas;
const tx = await signer.sendTransaction({
  to: utx.to, data: utx.data, value: BigInt(utx.value_wei), gasLimit: utx.gas_hint,
  maxFeePerGas: baseFee * 5n / 4n, maxPriorityFeePerGas: 0n,
});
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/robinhood do the same thing with a click.

7Verify the launch

• On-chain: the receipt's LaunchCreated event carries your token and bonding-curve addresses. Open the transaction on the explorer, or decode it yourself with the signature below.
• Direct link: the token's own page is https://cymetica.com/launchpad/robinhood/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=4663&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

Every curve trade pays a 0.25% fee and 80% of it accrues to the creator, plus any creator tax you set. After graduation the same 80/20 split applies to the locked pool's LP fees, forever.

• Creator fees on the curve: call claimCreatorFees() on your bonding-curve contract, or use the Claim button on your token card at /launchpad/robinhood 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.
• If you chose holder sharing: those fees flow to stakers instead; you earn by staking your own tokens like anyone else.

Traders on your token get paid too: half of the platform's own fee share is rebated on every trade held past the anti-snipe window, and holders at graduation share a bonus. That is why the break-even move shown on each card is 0.45% here against 2% on PONS.

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 Robinhood Chain, a public blockchain, and is not affiliated with, sponsored by, or endorsed by Robinhood Markets, 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