pawmp — Autonomous Token Management for AI Agents

Launch a token on pump.fun, collect 100% of creator fees, and buy back — all from a single skill file. No platform. No API. No middleman.

Why Launch a Token?

Every token on pump.fun generates creator fees from trading activity. With pawmp, your agent controls the entire flow — from wallet to launch to buyback — directly on Solana.

If you want revenue: Your token earns SOL from every trade. Unlike platforms that skim 35%, your agent keeps 100% of creator fees. $10,000 in daily trading volume means ~$3,000/month in your agent's wallet. Not someone else's.

If you want autonomy: Your agent doesn't call an API. It doesn't depend on a platform's uptime, rate limits, or rules. It talks directly to Solana. If pawmp disappears tomorrow, your agent keeps running.

If you want a sustainable loop: Claimed fees are used to buy back the agent's own token. This creates a self-reinforcing cycle — trading generates fees, fees fund buybacks, buybacks increase token activity.

Revenue Comparison

| Daily Trading Volume | Platform (65% of fees) | pawmp (100% of fees) |

|---------------------|------------------------|-------------------------|

| $1,000 | ~$195/mo | ~$300/mo |

| $10,000 | ~$1,950/mo | ~$3,000/mo |

| $50,000 | ~$9,750/mo | ~$15,000/mo |

| $100,000 | ~$19,500/mo | ~$30,000/mo |

pump.fun charges a 1% creator fee on every trade. With pawmp, your agent keeps all of it.

How It Works

pawmp is not a platform. It's a skill file. Your agent reads it, understands the rules, and executes everything on-chain.

1.Wallet — Agent checks for an existing wallet. If none exists, it generates a new Solana keypair and saves it. One agent, one persistent wallet.

2.Funding — First run only: the agent prints its address and waits for 0.025 SOL (rent + fees). After that, the wallet is funded and ready.

3.Launch — Agent uploads token metadata to pump.fun's IPFS, builds a create instruction via the pump-fun SDK, signs it, and sends it to Solana mainnet. Zero initial buy.

4.Collect — Every trade on the token generates creator fees. The agent periodically claims them into its own wallet using claimCreatorFee.

5.Buyback — Claimed fees are immediately used to buy back the agent's own token via buyToken. No other coins. The loop continues.

Quick Start

Step 0 — Wallet Setup (one-time)

Your agent needs a persistent Solana wallet. It generates one on first run and reuses it forever.

import { Keypair } from "@solana/web3.js";
import fs from "fs";
import path from "path";

const WALLET_DIR = path.join(process.cwd(), "wallets", "agent-1");
const WALLET_FILE = path.join(WALLET_DIR, "keypair.json");

function loadOrCreateWallet() {
  if (fs.existsSync(WALLET_FILE)) {
    const data = JSON.parse(fs.readFileSync(WALLET_FILE, "utf-8"));
    const keypair = Keypair.fromSecretKey(Uint8Array.from(data.secretKey));
    console.log("Wallet loaded:", keypair.publicKey.toBase58());
    return keypair;
  }

  fs.mkdirSync(WALLET_DIR, { recursive: true });
  const keypair = Keypair.generate();
  fs.writeFileSync(WALLET_FILE, JSON.stringify({
    publicKey: keypair.publicKey.toBase58(),
    secretKey: Array.from(keypair.secretKey),
  }, null, 2), { mode: 0o600 });

  console.log("New wallet created!");
  console.log("Address:", keypair.publicKey.toBase58());
  console.log("Fund this wallet with minimum 0.025 SOL to launch.");
  return keypair;
}

const wallet = loadOrCreateWallet();

Step 1 — Wait for Funding (first run only)

import { Connection, LAMPORTS_PER_SOL } from "@solana/web3.js";

const connection = new Connection("https://api.mainnet-beta.solana.com", "confirmed");

async function waitUntilFunded(publicKey, minSol = 0.025) {
  const minLamports = minSol * LAMPORTS_PER_SOL;
  while (true) {
    const balance = await connection.getBalance(publicKey);
    if (balance >= minLamports) return balance;
    await new Promise(r => setTimeout(r, 5000));
  }
}

Step 2 — Upload Metadata & Launch Token

import { Keypair, Transaction } from "@solana/web3.js";
import { PumpFunSDK } from "@pump-fun/pump-sdk";

const form = new FormData();
form.append("file", imageBlob, "icon.png");
form.append("name", TOKEN_NAME);
form.append("symbol", TOKEN_SYMBOL);
form.append("description", TOKEN_DESCRIPTION);

const { metadataUri } = await fetch("https://pump.fun/api/ipfs", {
  method: "POST", body: form,
}).then(r => r.json());

const sdk = new PumpFunSDK({ connection });
const mintKeypair = Keypair.generate();
const { instructions } = await sdk.createInstruction(
  wallet.publicKey, TOKEN_NAME, TOKEN_SYMBOL, metadataUri,
  { unitLimit: 250_000, unitPrice: 250_000 }
);

const tx = new Transaction().add(...instructions);
tx.sign(wallet, mintKeypair);
await connection.sendRawTransaction(tx.serialize());

Step 3 — Claim Creator Fees

async function claimFees(mintAddress) {
  const fees = await sdk.claimCreatorFee(wallet, mintAddress);
  if (fees > 0) console.log("Claimed", fees, "SOL");
  return fees;
}
setInterval(() => claimFees(mintAddress), 30 * 60 * 1000);

Step 4 — Buy Back Own Token

async function buyback(mintAddress) {
  const balance = await connection.getBalance(wallet.publicKey);
  const buyAmount = balance - 0.01 * LAMPORTS_PER_SOL;
  if (buyAmount <= 0) return;
  await sdk.buyToken(wallet, mintAddress, buyAmount);
}

Agent Rules

Allowed

-Create tokens on pump.fun

-Claim creator fees from own tokens

-Buy back own token using claimed fees

-Manage its persistent wallet

Forbidden

-Trade or buy other tokens

-Sell own token

-Use external SOL for buybacks (only use claimed fees)

-Share or expose wallet private keys

-Send SOL to any address other than pump.fun buy instructions

SDK Reference

pawmp uses the @pump-fun/pump-sdk package.

createInstruction(creator, name, symbol, metadataUri, options)

Creates a new token on pump.fun.

buyToken(wallet, mintAddress, amountInLamports)

Buys tokens on pump.fun using SOL.

claimCreatorFee(wallet, mintAddress)

Claims accumulated creator fees for a token you created.

vs. Launch Platforms

| | Launch platforms | pawmp |

|---|---|---|

| How it works | Agent calls a third-party API | Agent talks directly to Solana |

| Wallet ownership | Platform owns the launch wallet | Agent generates and owns its wallet |

| Fee split | 35% taken by platform | 0% — agent keeps 100% |

| Rate limits | 1 launch per 24h | No limits |

| Dependency | Platform goes down, agent is stuck | Nothing to go down — it's a skill file |

| Autonomy | Agent depends on external service | Agent is fully self-sufficient |

Your agent owns its wallet, its token, and 100% of its revenue. That's it.