Agentmuse

Everything about Agentmuse, in one place.

How launches work, how pricing and graduation are computed, and how to read any of it straight off the chain.

Overview

Agentmuse is where fixed-supply tokens are launched and traded on Robinhood Chain, and where the wallets trading them are ranked in public. Launches settle through public, permissionless contracts on chain, so every price, balance and fill on this site can be checked against the chain itself.

Agentmuse never holds your funds. Every launch and every trade is a transaction your own wallet is asked to approve, and every one is simulated against the live contract first, so a call that would fail never reaches your wallet.

Key facts
  • Names and tickers can be copied. Always check the contract address.
  • Prices come from each token's own bonding curve or pool, live.
  • Launches can be volatile, illiquid, or lose all value.

Launch mechanism

Creating a launch deploys the token and its own bonding curve in a single transaction. The full supply is minted into the curve — no team allocation is withheld — and the creator sets the name, ticker, image, description, links and fee wallet at creation. Those are written on chain and are immutable.

  1. 01CreateThe token and its curve deploy together. The entire supply is minted into the curve.
  2. 02TradeAnyone can buy or sell against the curve immediately. Price moves along a constant-product curve.
  3. 03GraduateOnce the curve has taken in its threshold, it is swept into a Uniswap V4 pool with permanently locked liquidity.

The live configuration uses a fixed supply of one billion tokens, a 1% trade fee, and a 0.0005 ETH launch fee. A creator may add their own tax of up to 10% on top, fixed permanently at launch, and may take an opening position in the same transaction.

Opening-window protection

For the first seconds after a launch, buys carry a steep tax that decays to zero. It starts at 99% and the window is short — read currentSnipeTaxBps(recipient) rather than assuming a duration, because the protocol owner can change it. The creator and their fee recipient are exempt automatically.

Trading and pricing

Before graduation every token trades against its own bonding curve, not a pool. Price is derived from the curve's reserves: it rises as people buy and falls as they sell. Fees are always charged on the quote leg, so the curve never holds fees denominated in the memecoin.

Price
Quote paid per whole token on the most recent trade.
Market cap
Price multiplied by the full supply.
Slippage
How far the price may move before your trade reverts.
Minimum out
The floor your trade is guaranteed, enforced by the contract.

A buy that would cross the graduation cap is not rejected. It is filled up to the cap, charged only for what it received, and the remainder is refunded in the same transaction.

Graduation

A launch graduates once its curve has taken in the graduation threshold — 4.2 ETH under the live configuration. The proceeds seed a full-range Uniswap V4 pool whose position is permanently locked: there is no withdrawal path, for anyone.

Graduation confirms a threshold was reached. It is not a quality signal and guarantees nothing about future liquidity, price, or your ability to exit.

Tokens that must leave the curve before graduation
reserved  = floor(supply × phantomQuote ÷ (phantomQuote + graduationThreshold))
toSell    = supply − reserved

// Live progress is curve.sellableTokens(); it reaches zero at graduation.
// Summing CurveBuy events drifts: sells return tokens and buybacks remove them.

Fees and creator revenue

Trading generates a fee on the quote asset, split between the protocol, the creator, and an optional buyback. A creator's own tax, if they set one, is paid to them in full on top of that split.

Creator fees accrue in the protocol's escrow contract, credited to the address recorded at launch. They are pulled, never pushed: the creator claims them from their own wallet. Fees are claimed directly from the escrow by whoever earned them — they never pass through Agentmuse, so there is nothing for anyone here to withhold, lose or misroute.

Risk disclosures

Tokens launched through this interface are user-created and experimental. Review the contract address, the creator, liquidity, and the transaction preview before signing.

  • Prices can move quickly and liquidity can be thin.
  • Similar names and images can represent completely unrelated tokens.
  • Smart contracts, wallets, RPCs and indexers can fail.
  • Displayed values are estimates, not execution guarantees.
  • These contracts were unaudited at the time of writing; audits were reported in progress with no published reports.

Agentmuse is an interface. It is not investment advice, and it is not a representation about any token's quality or safety.

Integration

A minimal, verifiable integration surface.

Everything reads directly off the contracts. Index the factory and curve events for a trust-minimised source of truth.

Network

Network
Robinhood Chain
Chain ID
4663
Native asset
ETH
Public RPC
https://rpc.mainnet.chain.robinhood.com
Explorer
https://robinscan.io
Supply per launch
1,000,000,000 (1e9)
Launch fee
0.0005 ETH
Graduation threshold
4.2 ETH (native quote)
Quote assets are not always ETH

Around 15% of live launches quote in an ERC-20 instead — tokenised equities such as NVDA, TSLA and BABA, and a 6-decimal stablecoin. Read the quote asset's own decimals, and never sum volume across different quote assets.

Contracts

Deployed addresses on Robinhood Chain, as used by this interface.

V2 factory0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7e
Launch-and-buy router0xe33E9E479dF8802cb0866d5d05258bEc4cF62948
Bonding curvedeployed per launch — see TokenLaunched
Fee escrow0xd3AFEB2a57f70eF218Aa82451c51B2fb0416Ac9e
Buyback vault0x42df2a798f82289E177311362e8f5ccC45c1219c
Position locker0x267444D099b10fB5Ed7c3Cc7B7c767AdcA574952
Meme hook0xE5e702641Ea86F4ae6cC3cDaeD2B886f976Be044
Uniswap V4 PoolManager0x8366a39CC670B4001A1121B8F6A443A643e40951
Uniswap V4 PositionManager0x58daec3116aae6D93017bAAea7749052E8a04fA7
Universal Router0x8876789976dEcBfCbBbe364623C63652db8C0904
Permit20x000000000022D473030F116dDEE9F6B43aC78BA3
WETH0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73
V1 factory (legacy, closed)0xA5aAb3F0c6EeadF30Ef1D3Eb997108E976351feB

Onchain events

Index the factory's TokenLaunched, then each launch's curve for CurveBuy and CurveSell. Curves are deployed per token, so scan trades by topic across all addresses rather than by contract.

topic0
TokenLaunched  0x8d4aad4953d0ca700d468f3753aa14432d1b35b43ec6409f051fb6aa43a89607
PoolGraduated  0x0a44ef75df69c534f43cd6c1aa3ef8983065fe5fe79ef9e79f6494e6f258c259
CurveBuy       0xec36bf571f136799e8dc0b0b8bea4b04d8bd3d43de838aab0d5fc21d4cbfc455
CurveSell      0x8113d738abdcb6b38357e9d53a54a7157861a09031b453651f0fe7fe151f59df
Practical limits of the public RPC
  • eth_getLogs rejects any query matching more than 10,000 logs. The cap is on the result, not the range, so no fixed chunk size is safe — halve the window on failure.
  • It is not an archive node. Historical eth_call fails; rebuild history from events plus current reads.
  • Logs carry a blockTimestamp field, but every public endpoint returns it as 0x0. Fetch block timestamps separately.

Reading token state

Every launch token is self-describing on chain. Read its metadata from the token contract and its economics from the curve — no off-chain source required.

Token metadata and curve state
const tokenAbi = parseAbi([
  "function name() view returns (string)",
  "function symbol() view returns (string)",
  "function decimals() view returns (uint8)",
  "function totalSupply() view returns (uint256)",
  "function logo() view returns (string)",
  "function description() view returns (string)",
  "function socials() view returns (string,string,string,string,string)",
])

const curveAbi = parseAbi([
  "function getReserves() view returns (uint256 quote, uint256 token)",
  "function realQuoteReserve() view returns (uint256)",   // raised so far
  "function sellableTokens() view returns (uint256)",     // zero at graduation
  "function graduationThreshold() view returns (uint256)",
  "function feeBps() view returns (uint256)",
  "function creatorTaxBps() view returns (uint256)",
  "function currentSnipeTaxBps(address) view returns (uint256)",
])

The launch record lives on the factory: getLaunchedToken(token) returns the curve address, the creator, the fee recipient, the quote asset, the graduation threshold and the current phase.

Create a coin →