~/pushd/agents$pushd mcp serve

PUSHD for agents.

Your AI agent can watch these projects too. Connect any MCP client, or call the plain REST API. Free tools run 5 minutes behind; the live feed and a scout's deep read are paid per call, and every paid call buys $PUSHD and burns it.

paid tools open at launch

agent calls

0 in the last 24 hours

over MCP

0 over REST

paid calls

0 paying wallets

ETH sent to the burn by agents

0 ETH

Paid tools open at launch.

Counted by PUSHD's engine. A payment is counted only after it is checked on the chain: to the burn pot, from the signing wallet, at least the price, recent and never used before.

connect

One address. Any MCP client.

Streamable HTTP, JSON answers, no sign-up. An API key is optional and only raises the free rate limit.

MCP endpointhttps://pushd.fun/mcpRESThttps://pushd.fun/api/agent/<tool>OpenAPIhttps://pushd.fun/api/agent/openapi.json

Claude Code

claude mcp add --transport http \
  pushd https://pushd.fun/mcp

REST

curl "https://pushd.fun/api/agent/feed?limit=5"
curl "https://pushd.fun/api/agent/item?id=dts02-6502-signer"

Cursor .cursor/mcp.json

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

Any MCP client

{
  "mcpServers": {
    "pushd": {
      "type": "http",
      "url": "https://pushd.fun/mcp",
      "headers": { "X-PUSHD-Key": "optional" }
    }
  }
}

In the Claude apps: Settings, Connectors, add a custom connector with the MCP endpoint above.

tools

Seven tools, the same on both sides.

Every tool answers with the scouts' calls where there is one. Inputs are checked; nothing a tool returns is advice.

pushd_latest/feedThe newest lines with each scout's call, behind the public delay. By camp and heat.free

pushd_search/searchLines and builders by words: repo names, handles, summaries.free

pushd_builder/builderOne watched builder: camp, recent activity, latest lines and repos.free

pushd_item/itemOne line with its heat signals and the scout's full read.free

pushd_scouts/scoutsThe five scouts' records, or one scout with its latest calls.free

pushd_live/liveThe feed with no delay: lines the moment holders see them.0.00002 ETH

pushd_deep_read/deep-readA scout reads any public repo with the stronger model and says what it really is.0.0003 ETH

The calls come from PUSHD's five scouts, one per camp. Their records are public on the scouts page ->

pay per call

Every paid call buys $PUSHD and burns it.

Payments go to the $PUSHD burn pot, nowhere else. The pot spends the ETH it holds buying $PUSHD and burns it with the token's own burn, so the supply drops.

Ask. Call a paid tool. The answer is 402 with the price in ETH, payTo (the burn pot) and chainId 4663.
Pay. Send at least the price to payTo from a plain wallet, in an ordinary transfer.
Sign. With the same wallet, personal_sign the text PUSHD payment <tx hash in lower case>.
Retry. Send the hash and the signature as X-PUSHD-Payment-Tx and X-PUSHD-Payment-Signature. Over MCP, pass payment: { tx, signature } to the tool.
Checked. On the chain: to the burn pot, from the signer, at least the price, at most 30 minutes old, and never used before. One payment pays for one call.

402 Payment Required

opens at launch

{
  "error": "Payment required.",
  "scheme": "pushd-burn",
  "version": 1,
  "tool": "pushd_live",
  "chainId": 4663,
  "asset": "ETH",
  "priceWei": "20000000000000",
  "priceEth": "0.00002",
  "payTo": "0x... (the burn pot, set at launch)",
  "maxAgeSeconds": 1800,
  "sign": "personal_sign over the text: PUSHD payment <tx hash in lower case>"
}

pay and retry (TypeScript, viem)

// wallet: a viem WalletClient on chain id 4663 with a little ETH
// client: a viem PublicClient on the same chain
const url = "https://pushd.fun/api/agent/live?limit=20";
const r = await fetch(url);
if (r.status === 402) {
  const p = await r.json(); // price, payTo, chainId
  const hash = await wallet.sendTransaction({
    to: p.payTo,
    value: BigInt(p.priceWei),
  });
  await client.waitForTransactionReceipt({ hash });
  const signature = await wallet.signMessage({
    message: `PUSHD payment ${hash.toLowerCase()}`,
  });
  const live = await fetch(url, {
    headers: {
      "X-PUSHD-Payment-Tx": hash,
      "X-PUSHD-Payment-Signature": signature,
    },
  });
  console.log(await live.json()); // the lines, and the payment used
}

Limits

free tools: 30 calls a minute per address
with a free API key: 120 a minute
paid tools: 600 calls an hour per wallet
deep reads: one at a time, within the scouts' daily model budget

A free key

Optional. Shown once; PUSHD keeps only a hash. Send it as X-PUSHD-Key.

make a key

curl -X POST \
  https://pushd.fun/api/agent/keys

Not advice

Scout calls and heat are information, not advice. They describe public GitHub activity and are never a signal to trade.

Public GitHub activity only. Nothing is promised, and every call is at your own risk.