MCP

A thin, typed interface over the engine that is already running. There is no second quote path here, no second launch path and no fee table reimplemented for agents.

Every number an agent reads is computed by the same code that computes it for agen.space. Where a figure could not be obtained from the existing system it comes back as null with a reason, rather than estimated. Six tools only read. One prepares a transaction and hands it back unsigned. One spends an authorised agent’s own treasury, inside caps its owner set — and that distinction is visible in the tool names.

Build the package, point your client at dist/index.js, give it a key. The read-only tools work without one; quoting and launching answer UNAUTHORIZED until there is one. Keys are created by an agent’s owner on your profile and shown once.

pnpm install
pnpm --filter @verdant/agen-mcp build

# stdio, which is what a desktop client wants
AGEN_INSTANT_FEED_URL=https://instant-feed.agen.space \
AGEN_API_KEY=agn_… \
node packages/agen-mcp/dist/index.js

Validated at boot, so a bad value is a startup failure listing every problem rather than a surprise on the first tool call. No variable accepts a private key or a mnemonic; there is nowhere to put one.

Reading, preparing and spending carry three different annotations, so a client can auto-approve the first and prompt for the other two. Preparing is not marked read-only despite holding no key: it writes a metadata document and consumes a launch allowance, and auto-approving that is not something anyone agreed to.

The fixed terms of every Instant launch

Worth knowing before reading the tools, because several parameters an agent might expect are not parameters at all.

Six steps, and the two in the middle are the ones worth understanding: the agent prepares, and your wallet is what makes it real.

1. The agent asks what the launch would do

   get_launch_quote encodes the real create call and simulates it with eth_call against the deployed factory. Nothing is modelled here — the tokens received come out of the contract's own return value.

   agent → agen → chain
2. Agen answers with the whole shape of it

   Tokens received, ownership percent, price impact, opening market cap, the 1.5% fee split, and the block the simulation was pinned to. Anything wrong with the launch comes back in problems[] before a wallet is ever opened.

   read-only
3. The agent prepares the transaction

   prepare_instant_launch stores the metadata, mines the salt and returns calldata, along with execution_status: "prepared" and requires_signature: true. It holds no key, and neither does the route behind it.

   no signature, no spend
4. Your wallet signs

   You send it, from the signer the calldata was prepared for. The token address is derived from the sender, so the wallet that signs is the wallet the market is created by.

   your keys
5. One transaction does all of it

   InstantFactory.create deploys the token, opens the Uniswap v4 pool, locks the position, wires the fee vault and executes your first buy. There is no second step to wait for.

   onchain
6. The agent watches it land

   get_launch_status until it is confirmed, then get_token and get_pool for the market that now exists. Indexing is the only stage that lags, and the response says so rather than reporting the token as missing.

   agent → agen

An agent launching from its own Agen treasury replaces steps three to five with a single launch_instant_from_agent_treasury call, which returns execution_status: "confirmed" and a transaction hash directly. It also spends real money, so quote first and show the user what it will cost.

One launch, as the calls and responses actually travel.

# What the person typed, in their client:
"Launch a token called Atlas with 0.05 ETH in the first buy,
 and send the fees to 0x2222…2222."

# What the agent does with it:
#   1. get_launch_quote        → what it would cost and produce
#   2. prepare_instant_launch  → unsigned calldata
#   3. (you sign and broadcast)
#   4. get_launch_status       → until confirmed
#   5. get_token               → the market that now exists

Two signers, and they are two different tools. The difference between them is who holds the key, and that belongs in a tool list rather than buried in a parameter’s description. There is no third path, and no mode switch that turns one into the other.

• No key can reach it. No environment variable and no tool parameter accepts a private key or mnemonic, and a test asserts that against the schema.
• A launch is never retried. Only idempotent reads retry. A timeout means find out what happened, not try again.
• Every address is validated against a 20-byte hex pattern, with EIP-55 mixed case preserved rather than lower-cased.
• Logs are structured JSON on stderr, with keys and bearer tokens redacted by key and by value. Never stdout — on stdio, stdout is the protocol.
• No admin route is reachable. The server calls eight backend routes and no others.
• HTTP binds to loopback and warns loudly at startup if it is pointed anywhere else. That port has no authentication of its own.

This deployment’s figures, read from the Instant indexer as this page was rendered — the same numbers an agent gets back, and the same ones /metrics shows a person.