Highwire

Highwire

The agent wire for higher.fun. Highwire is an MCP server that lets AI agents use higher.fun, the open-source Solana launchpad. Lower Fees, Higher Together.

Live at highwire.fun. Follow @Highwiredotfun on X.

Agents can scan launches and trending coins, pull a coin's trades, holders, candles and safety data, look up creators and their earnings, and run a rug check, all from the public higher.fun API and Solana RPC. No keys needed.

Sign from any chat. Highwire quotes trades and builds buys, sells, coin launches and creator fee claims as unsigned transactions, hosted or local. Each comes with a sign_url: open it, and highwire.fun/sign re-checks and simulates the transaction in your browser, then your own wallet signs. Highwire never signs, never holds a key and never sends anything. See docs/ROADMAP.md.

Or let your agent act, inside your rules. The local server has an opt-in signer: point it at a keypair file on your machine, write a policy (actions, coins, slippage, SOL per transaction and per day, transfer recipients), and the execute tools sign and send only inside it. Dry run until the policy says "live": true. See Local signer.

Tools

Transactions (hosted and local):

Every build tool decodes its own transactions into plain-language lines, checks them the way higher.fun's site does, simulates them, tags each with a highwire memo, and returns a sign_url. The output format, the sign links and the sign page are in docs/unsigned-transactions.md.

Local only:

The sign page (highwire.fun/sign) reads the transaction from the link's fragment, which never reaches a server, decodes every instruction from the bytes, shows what you spend and receive, the fees, the fee payer and the expiry, simulates against a Solana RPC straight from the browser, and signs with Phantom, Solflare, Backpack or any Wallet Standard wallet. It refuses anything off the allow-list, an expired blockhash, a failed simulation or the wrong wallet, and sends nothing to Highwire. Trade and claim links last up to 10 minutes (the page refreshes the blockhash and changes nothing else); launch links, whose new mint is already signed, about a minute.

Safety:

• Highwire never asks for, accepts or stores a private key or seed phrase. The user signs in their own wallet.
• Every instruction must be one Highwire builds, for the signing wallet's own accounts, on higher.fun's platform configs and fee tier. The launch fee must go to the fee wallet recorded on-chain and be at most 0.05 SOL. A transaction that fails a check is never returned; one that fails simulation comes back as an error.
• Caps: max_slippage_bps at most 1500, and no transaction moves more than HIGHWIRE_MAX_SOL_PER_TX (10 SOL by default).
• A launch's new mint is fixed per idempotency_key, so a retry reuses it and the coin (and its fee) can only happen once. The mint is derived with HMAC-SHA256 from a secret, the key and the launch (cluster, wallet, name, ticker, fee mode), so the same retry gets the same mint on any hosted instance or after a local restart, and once the coin exists a retry returns already_launched. The hosted endpoint uses HIGHWIRE_LAUNCH_SECRET; the highwire CLI uses it when set, and otherwise a random secret it creates once in ~/.highwire/launch-secret. Reusing a key for a different coin gets a different mint.
• If the coin was created but its creator lock was never assigned (the launch's second transaction expired or failed), a retry with the same key builds just the assignment.
• higher.fun's image and metadata upload needs a wallet sign-in, so build_launch takes a hosted metadata_uri. Without one it returns the metadata JSON to host. With the local signer, execute_launch takes image_path instead: the signer signs higher.fun's sign-in message (checked word for word, and nothing else), uploads the image and metadata, and launches. Only a real PNG, JPEG, GIF or WebP of at most 4 MB is uploaded, and never a file from the signer's folder.
• execute_launch also takes launch_for (New school): an X or GitHub handle. higher.fun resolves it to the wallet that holds that account's creator fees until they claim at higher.fun/claim; the coin is created for that wallet, which gets 0.005 SOL from you if it holds less, and your first buy is still yours. The sign page never signs a launch for someone else, so this needs the local signer. higher.fun hasn't switched the lookup on yet (it answers "isn't switched on yet"); until it does, execute_launch stops with launch_for_unavailable before uploading or spending anything.

Prompts:

• scan_launches
• coin_due_diligence
• creator_report
• plan_launch

Resources:

• higher://platform
• higher://coins/{mint}

Skill: an operator guide for agents is in packages/mcp/skills/highwire/SKILL.md.

Connect

Hosted

Nothing to install, no key. The hosted server has all 26 tools; the build tools only return unsigned transactions and a sign link.

Claude Code

claude mcp add --transport http highwire https://highwire.fun/mcp

Cursor, or any client that takes a remote MCP URL

{

"mcpServers": { "highwire": { "url": "https://highwire.fun/mcp" } } }

The endpoint speaks stateless Streamable HTTP: POST JSON-RPC, get JSON back. Each IP gets 60 units a minute: a build tool or watch_market call costs 5, a few heavy reads 2 to 10, anything else 1.

Local (stdio)

Needs Node 20 or later; live alerts (watch_market, highwire watch) need Node 22, for its built-in WebSocket.

Claude Code

claude mcp add highwire -- npx -y highwire-mcp

Claude Desktop, Cursor, or any stdio client

{

"mcpServers": { "highwire": { "command": "npx", "args": ["-y", "highwire-mcp"], "env": { "SOLANA_RPC_URL": "https://api.mainnet-beta.solana.com" } } } }

Environment variables. All are optional; see .env.example.

The site (apps/web) also reads NEXT_PUBLIC_SOLANA_RPC_URL and NEXT_PUBLIC_SOLANA_DEVNET_RPC_URL, the RPCs the sign page calls from the browser, and allows only their origins in its CSP. The public RPC is rate-limited, and the public mainnet endpoint refuses requests from web pages (HTTP 403), so the deployed site needs its own mainnet RPC there. For anything beyond light use, set SOLANA_RPC_URL to your own too (Helius, Triton, …).

Live alerts in the terminal

npx -y highwire-mcp watch --min-sol 1

prints higher.fun's live feed, one line an event, until Ctrl-C. --launches, --graduations, --buys and --sells pick what to show (all four by default), --mint keeps one coin's trades and graduations and adds each trader's wallet (repeat it for up to 16 coins), --min-sol drops small trades, and --json prints JSON lines instead.

Launch on your own

An agent with a shell can launch coins and collect their fees from its own wallet, with no one in the loop once it's set up. highwire.fun/skill.md walks an agent through it ("Read highwire.fun/skill.md and launch a coin"):

npx -y highwire-mcp wallet new                  # ~/.highwire/wallet.json, readable only by you; prints the address to fund

npx -y highwire-mcp policy init --launch --live # mainnet launches and claims, 0.25 SOL a launch, 0.5 SOL a day npx -y highwire-mcp launch --name "Cat Demo" --ticker CATDEMO --image ./cat.png --buy 0.02 npx -y highwire-mcp claim # the creator fees

launch signs in to higher.fun with the wallet, uploads the