DOCUMENTATION

$SIZE is autonomous infrastructure built entirely on pump.fun's official Agent Skills SDK. It turns idle creator fees into productive, leveraged on-chain capital. Every cycle, the agent claims accumulated creator fees using the coin-fees skill, consults an AI brain for an entry decision, executes swaps via the swap skill, and opens a real spot-leveraged PUMP position on spot margin. Every action is logged. Every transaction is on-chain. Every reasoning is published in plain English.

This project is only possible because pump.fun released their Agent Skills — giving programmatic access to fee collection, sharing configs, token swaps, and payment verification that previously required manual interaction. $SIZE is a demonstration of what becomes possible when a platform opens its infrastructure to autonomous agents.

The flagship vault routes SIZE's own creator fees into leveraged PUMP longs because PUMP is the meme that started everything. But the engine is not hardcoded to PUMP — the target token, host token, leverage, and split are all configuration. SIZE is the pattern, sold as infrastructure, to any meme that wants it.

Pump.fun released an open-source collection of Agent Skillsthat teach AI agents how to interact with their on-chain programs. $SIZE uses all four skills in its pipeline. Before this SDK existed, building this pipeline meant reverse-engineering pump.fun's programs, manually resolving PDAs, handling bonding curve vs. AMM state transitions, and constructing raw Solana transactions from scratch.

coin-fees — Creator Fee Collection & Distribution

The core of the pipeline. Every 15 minutes, $SIZE calls the coin-fees skill to claim accumulated creator fees from connected token vaults. The skill automatically detects fee destinations — whether fees go directly to the creator, to a sharing config with multiple shareholders, or as cashback to traders. It resolves vault balances across both the Pump program and Pump AMM sides, and builds the correct claim transaction (collect for direct creator, distribute for sharing configs).

POST https://fun-block.pump.fun/agents/collect-fees
{
  "mint": "<TOKEN_MINT>",
  "user": "<AGENT_WALLET>",
  "encoding": "base64"
}

swap — Token Swaps with Auto-Detection

Used in two places: (1) the 30% buyback leg swaps SOL → $SIZE for burning, and (2) position entry/exit on $PUMP when needed. The swap skill automatically detects whether a token is still on the bonding curve or has graduated to the AMM pool, and builds the correct transaction type. Slippage protection and optional Jito front-runner protection are built in.

POST https://fun-block.pump.fun/agents/swap
{
  "inputMint": "So11111111111111111111111111111111111111112",
  "outputMint": "<TOKEN_MINT>",
  "amount": "1000000",
  "user": "<AGENT_WALLET>",
  "slippagePct": 2,
  "encoding": "base64"
}

create-coin — Token Creation with Tokenized Agent Support

$SIZE itself was launched using the create-coin skill with the tokenized agent flag enabled. This means the token natively supports pump.fun's built-in buyback mechanism — a portion of every trade automatically flows back into the protocol. The skill handles mint keypair generation, initial buy, metadata upload, and partial signing in a single transaction.

POST https://fun-block.pump.fun/agents/create-coin
{
  "user": "<CREATOR_WALLET>",
  "name": "SIZE",
  "symbol": "SIZE",
  "uri": "<METADATA_URI>",
  "solLamports": "1000000000",
  "tokenizedAgent": true,
  "buybackBps": 5000,
  "encoding": "base64"
}

tokenized-agents — On-Chain Payment Verification

For premium vault features (custom leverage targets, priority execution), $SIZE uses the agent-payments-sdk to build payment invoices and verify them on-chain. This enables a trustless paywall — no backend database of who paid, no API keys. The blockchain is the receipt. Supports both USDC and wrapped SOL as payment currencies.

import { buildAcceptPaymentInstructions, validateInvoicePayment }
  from '@pump-fun/agent-payments-sdk';

// Build payment instruction
const ix = buildAcceptPaymentInstructions({
  agentTokenMint, currencyMint, amount, invoiceId, startTime, endTime
});

// Verify on-chain (server-side)
const valid = await validateInvoicePayment(
  connection, agentTokenMint, currencyMint, invoiceId
);

Creator fees are the most underused primitive on Solana. Billions of dollars of volume flow through pump.fun. The creator fee system extracts a slice of every trade. That slice — across the entire ecosystem — represents an enormous stream of passive SOL that currently gets claimed and dumped. Friction on the engine of the meme economy.

SIZE is a proof that this does not have to be the default. Creator fees can be productive capital. They can compound into positions. They can fund buybacks. They can support the underlying memes that birthed them. And with the leveraged-pump-infrastructure model, any token can plug into the same infrastructure without rebuilding the wheel.

The pattern

The target token is a config variable. The host token is a config variable. The split is a config variable. The venue is a config variable. Swap PUMP for any token listed on a perpetual DEX or spot leverage protocol and the engine just works.

The pipeline is a deterministic loop running every 15 minutes. Each cycle has the same structure: check existing positions for exits, claim new fees, consult the brain, open a new position if the brain approves. No human intervention required after initial setup.

Stage 0: Exit monitoring

Stage 1: Claim

Stage 2: Split

Stage 3: Brain consult

Stage 4: Open

// Every 15 minutes, deterministic
exit_monitor.check_all_positions()      // Stage 0
fees = claim_creator_fees()              // Stage 1
if fees < 0.05 SOL → log SKIP, return

long_amount    = fees × 0.70             // Stage 2
buyback_amount = fees × 0.30

market   = fetch_market_context()        // Stage 3
decision = brain.decide_entry(
  long_amount, market, existing_positions
)
if decision.action == 'SKIP' → return

  collateral: long_amount,
  leverage:   decision.leverage,
  asset:      PUMP
})

log(position, redis)
register_open_tx(position, signature)

Most yield protocols are dumb loops. Claim, swap, deposit, repeat. That is fine when the yield source is stable and the exposure is delta neutral. That is not fine when you are taking leveraged directional positions on a memecoin.

The brain is the difference between an autopilot and a thermostat. Every cycle it reads live market context, returns a structured decision with explicit reasoning, and logs both to Redis for the dashboard to display in real time. Anyone can read the brain's reasoning for every decision it has ever made.

Inputs

Entry decision schema

{
  "action": "OPEN" | "SKIP",
  "leverage": 4.5,
  "reasoning": "PUMP showing positive 24h momentum with manageable
   volatility. Sizing at 4.5× to leave headroom on liquidation
   distance given 1h pullback. No existing position degrades to
   risk-off."
}

Exit decision schema

{
  "action": "HOLD" | "PARTIAL_CLOSE" | "FULL_CLOSE",
  "reasoning": "ROI is +4.76%, within HOLD range. Position is not
   under immediate threat of liquidation, interest cost is manageable,
   no strong momentum indicators suggest taking profit or cutting loss.",
  "urgency": "low" | "medium" | "high",
  "roi": 4.76,
  "distanceToLiq": 13.157
}

Live brain reasoning (pulled from /api/logs)

Why a brain instead of fixed thresholds

spot margin provides spot leverage — borrowing SOL against your collateral and using it to buy real tokens on-chain. Unlike perpetual futures (synthetic exposure), this creates actual buy pressure on the underlying asset.

Why spot margin over Drift

Position data exposed

$SIZE is a fair launch. No team allocation. No presale. No VC round. No locked supply with a 6-month unlock cliff we pretend doesn't exist. The token is deployed on pump.fun and the bonding curve is the distribution. There is no multisig we control, no upgrade key, no proxy contract standing between you and the tokens you hold.

Live on pump.fun

The split — every cycle, every fee

The 70/30 split is deliberate. 70 to leverage, because that is where the engine has to actually produce returns. 30 to burn, because that is the mechanism by which $SIZE holders get direct price support from trading activity that does not depend on the PUMP position being profitable. Even if the brain is flat for a month, the burn keeps firing every cycle and the supply keeps shrinking. Even if the PUMP side gets chopped up, the burn keeps firing. The two halves of the split are hedges for each other.

Deflationary by construction

Every cycle with non-zero fees triggers a burn (post-launch). The more the token trades, the more the supply shrinks, the more each remaining token represents a share of the engine's accumulated PUMP exposure and the engine's accumulated multi-vault revenue once Phase 2 ships. Volume is the fuel. Burn is the exhaust. The token holder sits in the driver seat, and the seat keeps getting smaller.

There is no staking. There is no LP farming. There is no yield contract that requires you to lock your tokens into a black box to earn airdrops of the next black box. Holding $SIZE is the entire participation mechanic.

You should not trust anything in this document. You should verify it. Every claim about how SIZE works can be reconciled against on-chain state and public APIs.

Live links

If anything in this document does not match what you can see on those endpoints right now, we screwed up and you should tell us. Building in public means the receipts are the product.

Three components, one loop. The agent claims and decides. The frontend watches and reports. spot margin, Jupiter, and Pyth are the external rails the system runs on. Redis is the shared memory. Everything else is glue.

1 · SIZE Agent (pipeline)

Node.js process running on a 15-minute cron. Handles fee claiming, splitting, brain consultation, position management, and exit monitoring. Survives RPC failures, slippage on open, and spot margin downtime. All actions logged to Redis with transaction signatures.

2 · Next.js frontend + API

Public-facing site and API layer. Serves the dashboard, docs, and real-time position data. API routes pull live data from spot margin, Pyth, and Redis on every request — nothing is cached beyond the route revalidation window.

3 · External protocols

Multi-vault architecture (Phase 2 forward spec)

The pipeline is already designed for multi-vault. Vaults are config objects with hostToken, targetToken, splitLong, splitBuyback, and venuefields. Adding a new vault is a config operation, not a code change. The brain handles per-vault reasoning by passing the vault's target into the market context call. Per-vault stats are stored under size:vault:<mint>:* Redis keys.

All endpoints are public, return JSON, and require no authentication.

GET /api/position

Live position data from spot margin and pipeline statistics from Redis. Returned shape (real example, current state):

{
  "live": true,
  "agentWallet": "DeMsAfZd8wUVqJEwYWKxQ74ubQ9QqBVgUDLR3CoqF9Zg",
  "position": {
    "hasPosition": true,
    "count": 2,
    "positions": [{
      "address": "C4YLBRkT",
      "openTx": "4YaAhySt2WCteu98sZqnpRd2w1ratSFNBjX9Y1MhKeFFJZ2F9WhZi6onyTQVyYgxuks5Bdn4si22zJddVU5ySUMJ",
      "side": "LONG",
      "collateral": 0.129904,
      "borrowed": 0.519616,
      "entryPrice": 0.0021541872,
      "currentPrice": 0.0021749972,
      "unrealizedPnl": 0.531612,
      "roiPercent": 4.83,
      "liquidationPrice": 0.0018885509,
      "effectiveLeverage": 4.816,
      "dailyInterestCost": 0.001409,
      "currentLtv": 0.7945,
      "liquidationLtv": 0.915
    }],
    "totals": { "collateral": 0.609927, "pnl": 2.476839, "avgLeverage": 4.8165 }
  },
  "stats": {
    "cycleCount": 8,
    "longCount": 9,
    "totalLongNotional": 10.983,
    "pendingBuyback": 2.787
  }
}

GET /api/pump-price

Current PUMP price from Pyth Network via Hermes API.

{
  "price": "0.0021749972",
  "source": "pyth",
  "updatedAt": "2026-04-11T01:15:00.000Z"
}

GET /api/logs

Recent agent activity. Each log has a type (CYCLE, BRAIN, CLAIM, LONG, EXIT, BUYBACK, BURN, ERROR), a plain-English message, an optional transaction signature, and optional structured details.

{
  "logs": [
    {
      "type": "BRAIN",
      "message": "Exit decision for 7jsFgFQb: HOLD — The current ROI is +4.76%, which is between -15% and +15%. The position is not under immediate threat of liquidation, and the interest cost is manageable.",
      "details": {
        "action": "HOLD",
        "reasoning": "...",
        "urgency": "low",
        "roi": 4.76,
        "distanceToLiq": 13.157
      },
      "timestamp": 1775869036657
    }
  ],
  "stats": { "cycleCount": 8, "longCount": 9, "claimCount": 24 }
}

$SIZE involves real financial risk. This section is not a disclaimer — it is a technical assessment of what can go wrong.

Liquidation risk

Borrowing cost risk

Brain failure modes

RPC and infrastructure risk

Smart contract risk

Market risk

No dates, because dates are a lie, but the sequence is not.

Phase 1 — PUMP engine · LIVE NOW

The flagship vault. SIZE creator fees route into leveraged PUMP longs via spot margin. AI brain making real entry and exit decisions. Dashboard live at pumpmax-site.vercel.app. Positions auditable on Solscan. This is the proof of concept.

Phase 2 — Multi-vault

The engine template goes public. Any memecoin project can deploy a SIZE-style vault for their own token with a permissionless flow: pick a target, pick a split, deploy. Creator fees from the host token fund longs on the target token and buybacks on the host token. One engine pattern, many memes fueled. The SIZE protocol earns a small fee on every vault, and SIZE holders get exposure to the entire fleet of engines running on the infrastructure.

Phase 3 — Hyperliquid expansion

Solana is home. Hyperliquid is the next room. We are building a Hyperliquid adapter so the SIZE brain can open perp positions on HYPE-listed memes and PUMP perps when they list. One brain, two venues. The Solana side keeps running on spot margin. The Hyperliquid side runs in parallel with its own agent, its own vault, and its own routing.

Phase 4 — Asset-backed memes

The long vision. After Hyperliquid integration, we start building the next layer: memecoins that are asset-backed by tokenized real-world assets. Oil. Gold. Commodities. Tokenized equities. Treasury bills. The SIZE engine already knows how to route SOL into long exposure. Point that same engine at a tokenized WTI crude contract or a tokenized basket of stocks, and the split changes from buy-back-the-host / long-the-meme to buy-back-the-host / long-the-real-asset.

The result is a memecoin whose price floor is reinforced by an on-chain, verifiable, automatically compounding position in something the real economy prices. A pump joke backed by a barrel of oil. A dog coin backed by a slice of the S&P. The culture stays degenerate. The collateral gets serious.

Phase 5 — Public brain

Eventually the brain itself becomes the product. A public endpoint any protocol can query to get a structured, market-context-aware leverage decision with reasoning attached. The brain as oracle. Until then it lives inside SIZE, making decisions for every vault.