vibecoin

Launch your vibe coded app on Solana or Robinhood Chain from your coding agent

Installation

No terminal needed — paste the prompt for your platform into your agent and it installs the server itself:

Claude Code

Install the vibecoin MCP server by running: claude mcp add vibecoin -- npx -y github:ivanbvz/vibecoin-mcp

Codex

Install the vibecoin MCP server by running: codex mcp add vibecoin -- npx -y github:ivanbvz/vibecoin-mcp

Cursor

Add the vibecoin MCP server to my Cursor MCP config at ~/.cursor/mcp.json: a server named "vibecoin" with command "npx" and args ["-y", "github:ivanbvz/vibecoin-mcp"].

Restart your agent afterwards and the tools are live. On any other MCP client, the prompt is the same idea in that client's words — the server is npx -y github:ivanbvz/vibecoin-mcp.

How it works

Open your coding agent inside whatever you're building and say "launch this as a coin". That's the entire workflow — no dashboard, no form, no leaving the terminal.

Your agent reads your README, package.json and git remote, drafts the coin (name, ticker, description, links), and shows you exactly what it's deploying and what it costs — then signs and launches it right there, no approvals, no wallets to set up, nothing for you to sign.

On approval it creates an encrypted wallet for this project — the password is generated for you and kept in your OS keychain, the keys never leave your machine — then deploys the coin. Pick your chain: pump.fun's bonding curve on Solana (the default), or Pons on Robinhood Chain with quotes in ETH or tokenized stock pairs. A coin attached to a real repo is an open prediction market on your app: if people believe in what you're shipping, they buy in early, and you earn a cut of every trade from day one.

Every project gets its own fresh wallet, so launches are pseudonymous by default — nothing links the coin to you until you decide to say so. Want extra credibility instead? lock puts part of your own bag in an on-chain time lock with a link you can share.

Available tools

ToolWhat it does
walletCreate the project's encrypted Solana wallet, check SOL/USDC balance, transfer SOL
launchDraft a coin from your repo and deploy it to pump.fun's bonding curve (Solana)
evm_walletCreate/import the encrypted Robinhood Chain wallet (chain 4663) — the chain Pons launches on
pons_pairsLive Pons quote assets — ETH plus tokenized stock pairs, index funds and stablecoins, with graduation thresholds
pons_launchDraft a coin from your repo and launch it on Pons: quote pair, creator tax on top of the 1% standard fee, reward vault, atomic dev buy
pons_feesPost-launch Pons fee settings: status, transfer the fee recipient, toggle the reward vault
my-coinsEvery coin launched from this machine on both chains, with live market data (Solana) and on-chain status (Pons)
collect-feesClaim creator fees on both chains in one command — pump.fun payouts plus the Pons fee escrow (ETH and stock-pair quotes)
fund-agentCollect fees and swap SOL→USDC so your agent has a budget
lockLock a % of your own tokens via Streamflow and get a proof link
infoFee table, config, wallets, links

Bonding curve

vibecoin deploys standard pump.fun coins — nothing custom, nothing upgradable, no contract of ours in the middle:

Total supply1,000,000,000 — all of it starts on the curve, zero pre-mine
PriceClimbs deterministically as the curve fills; earliest believers get the best price
GraduationWhen the curve sells out (~85 SOL raised, roughly a $70–100K market cap depending on SOL price)
After graduationMigrates to PumpSwap for 0.015 SOL and the LP tokens are burned — liquidity can't be pulled

Your creator allocation is whatever you choose to buy — a dev_buy_sol at launch fills your wallet at the very bottom of the curve, and lock can prove you're holding it.

Pons on Robinhood Chain

The second chain: pons_launch deploys to Pons (ponsfamily.com), the launchpad on Robinhood Chain (chain ID 4663 — an Arbitrum L2 with ETH gas). Same flow — the agent previews, signs and launches itself — same local-only keys; a separate encrypted EVM wallet is auto-created per project.

Total supply1,000,000,000, fixed by the protocol
GraduationBonding curve → permanently locked Uniswap V4 pool once the threshold is raised (default 4.2 ETH for ETH pairs) — anyone can trigger the sweep, nothing to migrate yourself
Quote pairsNative ETH, or ~23 approved ERC-20s read live with pons_pairs: tokenized stock pairs (NVDA, TSLA, AAPL, GME…), index funds (SPY, QQQ) and stablecoins. A stock-pair launch collects fees in that stock and graduates into a pool keyed in it
Creator taxYour cut of every trade, added on top of Pons's standard 1% fee — e.g. 1.5% creator tax means traders pay 2.5% total. Factory-capped (currently 10%), frozen at launch. Always paid to the launch wallet
Reward vaultOptional buyback: part of your creator tax buys back the token and releases linearly over 5 years, split with the protocol. Funded from your fees, not a holder distribution. Toggleable post-launch with pons_fees
Dev buyAn opening buy atomic with the launch, exempt from the 99% opening snipe tax (decays over 3 seconds). Keep one in — unbought launches have been sniped out within two blocks
Predicted addressCREATE2 deployment, so the preview shows the token and curve addresses before anything is sent
Launch fee~0.0005 ETH, read live — the factory demands it exactly

Post-launch, pons_fees manages what Pons lets a creator change: transfer the fee recipient (immediate, also re-points the reward vault) and toggle the reward vault. The tax rate itself is frozen forever — there is no setter on the contract. Protocol-side fees are owner-only globals, never per-launch settings. Claim what you're owed with collect-fees — one command covers both chains. Pons is a third-party platform, not a Robinhood product.

Fees

Two launchpads, two fee models. Solana first — launching on pump.fun:

Launch feeFree — ~0.025 SOL of network cost puts it on-chain
Trading fee on the curve1.25% per trade
API fee0.5% on trades routed through PumpPortal (dev buys included; creating is not charged)

Where the 1.25% goes

Creator (you)0.30% of every curve trade
pump.fun protocol0.95%

After graduation the creator share is tiered by market cap: it peaks at 0.95% per trade in the $85–300K range and floors at 0.05% above ~$20M, with 0.20% to LPs and 0.05% to the protocol. Claim whenever you like with collect-fees — it costs a network fee, nothing more.

Pons on Robinhood Chain

Launch fee~0.0005 ETH, read live from the factory and demanded exactly
Protocol fee1% of every trade — the Pons standard, on the curve and after graduation
Creator tax (you)Your chosen percentage on top of the 1% — factory-capped at 10%, frozen at launch, always paid to the launch wallet
Reward vaultOptional: a slice of your creator tax funds a buyback vault, 5-year linear release, protocol takes a share of releases
Opening protection99% snipe tax decaying over 3 seconds at launch; your dev buy rides exempt in the same transaction

Gas on Robinhood Chain is paid in ETH and negligible beside the launch fee. Manage the recipient and the reward vault afterwards with pons_fees.

Fund your agent

The part that closes the loop: your coin's trading fees can pay for the agent that built the app.

> collect my fees and fund the agent

One prompt runs fund-agent: claim pending creator fees, keep a little SOL for gas, swap the rest to USDC through Jupiter, and leave the budget sitting in the project's own wallet. Ship something people trade, and the meter runs backwards.

Straight talk: the USDC stays in a wallet you control. Anthropic and OpenAI bill fiat cards only, and OpenRouter's crypto top-up is a manual checkout on their site — nothing here auto-pays a provider, and we won't pretend otherwise.

Projects

Every coin launched here ships with receipts — the GitHub repo and the live URL are first-class fields, not an afterthought. Browse what people are building and trade the ones you believe in.

Browse projects →

API

Everything the site knows is public JSON. Build dashboards, bots, or your own frontend on top.

Endpoints

GET /api/projectsAll launched projects with live market data, sorted by market cap
POST /api/registryCalled by the MCP after a launch — registers mint, links and metadata
POST /api/metadataHosts your token's metadata JSON + image and returns the URI for the create transaction

Example

$ curl -s https://vibecoin.fun/api/projects
{
  "count": 1,
  "projects": [
    {
      "mint": "…pump",
      "name": "Rocket Notes",
      "symbol": "ROCKET",
      "description": "A note-taking app that syncs your thoughts to the moon.",
      "github": "https://github.com/you/rocket-notes",
      "website": "https://rocketnotes.app",
      "creator": "…",
      "createdAt": "2026-07-30T00:00:00.000Z",
      "market": { "priceUsd": 0.0000031, "marketCapUsd": 3100, "volume24hUsd": 950 }
    }
  ]
}

Token metadata — what goes where

The launch tool fills these for you from the repo; every one can be overridden. This is the full field reference your agent works from:

FieldLives inFunction & limits
nameon-chain + metadata JSONToken name, 32 chars max. Drafted from your README title or package.json name.
symbolon-chain + metadata JSONThe $TICKER, 10 chars max (3–8 uppercase is the norm). Drafted from the name.
descriptionmetadata JSONShown on the pump.fun coin page. Drafted from your README's first paragraph; keep it under ~500 chars.
imagemetadata JSONCoin avatar. Square png/jpg/gif/webp under 1.5MB. Auto-detected from logo.png and friends, else a placeholder.
websitemetadata JSONLink on the coin page — point it at your live app. This is the whole point.
twitter / telegrammetadata JSONOptional social links on the coin page. Omitted unless you provide them.
githubregistry + descriptionpump.fun has no native repo field, so the repo URL lives in our registry, on /projects, and gets appended to the description.
showNamemetadata JSONLegacy pump.fun flag, always "true" for compatibility.
createdOnmetadata JSONProvenance stamp. Coins launched here carry https://vibecoin.fun.