Grok agent watching pumpfun, but sixteen of them, organized into a desk. They monitor launches around the clock, filter the noise, argue with each other on purpose, and either buy early on the curve or pass. With architecture, code, an honest breakdown of why most people lose, and the one design choice that separates a desk from a slot machine.

Why 16 Agents, Not a Script and Not One

Memecoin sniping is a task you cannot solve with a one-shot prompt and can barely solve with a script. Tokens launch around the clock, the entry window is minutes, and the buy decision needs several things weighed at once: the bonding curve, wallet behavior, social signal, narrative, and the mood of the market that hour.

A script filters by metrics. A script cannot read a creator's Twitter thread and tell whether there is a community behind the token or a one-time dump waiting to happen. A script cannot judge why one meme goes viral this week and an identical one dies. A script cannot argue with itself.

But one agent doing all of it is a different failure. An agent that finds a token, scores it, and buys it is judge and executioner. It is too generous toward its own conclusion. It falls in love with the token it discovered.

Sixteen agents that each do one job are a jury. The scanner does not know why the rug checker killed the last mint. The snipers never hear what the social agent thinks until the score is already computed. They disagree by design, and the disagreement is the product. The desk is organized into three rings around a core:

Risk ring: the router, the supervisor, the risk manager. They size capital, hold the kill switch, and route nothing to a sniper that has not survived the other two rings.
Research ring: the scanner, the rug checker, the dev tracer, the social reader, and the book. They gather evidence. None of them can buy.
Sniper ring: eight execution agents. They fire on the curve and trail their own exits. They decide nothing.

And underneath all sixteen sits one shared memory. That memory is the part of this system nobody copies, and it is the part that actually compounds. We will come back to it, because it is the whole edge.

Pipeline Architecture

The desk runs as a loop. A launch enters at the scanner and either dies at a filter or exits as a buy. Every stage can run autonomously and hands its result to the next.

Scanner and snipers are code. The research ring and the supervisor check are separate Grok calls with different prompts and different roles. Market timing is cached and does not fire on every token. The supervisor runs only on tokens that already passed the score, meaning units per day, not thousands. The vault is written on every terminal event, buy or skip or close, because that is what the next launch reads from.

The Scanner: WebSocket and Stream Filtering

PF produces thousands of tokens a day and most are dead on arrival: no metadata, zero buyers, the creator gone after a minute. The scanner's only job is to kill the dead on the stream, before the desk spends a single model call.

A WebSocket feed from a data provider (Solana Tracker, PumpPortal, and similar) delivers launches in real time with basic metrics: address, metadata, curve state, transaction count. Filtering here is fast and cheap.

Two things matter here. The age filter cuts sniper tokens that are minted and bought out by bots in the first second. A token that survives two minutes with organic buyers is already above ninety percent of the stream. And the provider risk score, a rating built from snipers, insiders, bundlers, liquidity depth, and contract authorities, is the first automatic cut, killing toxic tokens before any Grok call is spent on them.

The Rug Checker: Killing Most of the Stream

Everything the scanner passes goes to the rug checker, and most of it dies here. Liquidity not burned, mint authority still live, dev wallet dirty, honeypot signature. Ninety percent and more of tokens that clear the basic filter never reach a buyer, and that is the point. The rug checker is the reason the snipers stay solvent.

Metrics catch known patterns. A token with no Twitter and no website where forty percent sits in one wallet is not an investment, it is a trap, and code cuts it for free. But metrics miss the novel schemes: bundle chains where ten wallets belong to one operator and buy in sequence, three seconds apart, in identical amounts. To a script those are three independent buyers. To the dev tracer, reading the intervals and the amounts, they are one coordinated purchase. That is where the research ring starts.

The Research Ring: Where Grok Earns Its Keep

Three agents gather what a script cannot. The dev tracer follows the deployer across his old rugs. The social reader judges whether a community is real or staged. The book scores narrative: why this meme fits the trend and that one does not. None of them can buy. They produce numbers that feed the core.

Here is the book, the narrative scorer, as the representative example. Every research agent has the same shape: strict JSON out, temperature zero, the collected metrics passed in so the model scores evidence instead of hallucinating it.

Notice the fallback. On a parse error the book returns zeros, not a silent pass. This rule holds for every agent on the desk: an error is a rejection, never a skipped check. If the model breaks, the token dies. And notice what the model does not do: it does not buy. It returns four numbers that enter a matrix next to the code metrics. The code decides, not the model. That single line, code decides not the model, is the difference between a desk and a gambler with an API key.

The Risk Core: Where Signals Become a Decision

The core is three agents wearing one hat: the router, the supervisor, and the risk manager. It aggregates every signal into one score, checks the market moment, and enforces the brakes.

Five brakes, each mandatory. A per-token ceiling, however high the score. A daily loss limit that stops the desk until tomorrow. A trade count cap, because twenty trades a day is twenty risks, not twenty chances. An open-position cap of three, to keep capital and attention from spreading thin. And size that shrinks as the daily limit approaches, so the last trades of the day are the smallest. An agent without brakes in this environment is a high-speed money-burning machine. The brakes are not good practice. They are the condition for the desk existing at all.

The Supervisor: Adversarial Verification Before the Buy

Every agent so far has worked toward yes. The supervisor works toward no. Its only job is to find a reason not to buy a token the rest of the desk already approved. This is the maker-checker pattern: the makers generate the score, the checker tries to destroy it, and no agent gets to grade its own work.

Two deliberate choices. The supervisor runs on a stronger model than the makers, grok-4 against grok-4-fast. The makers are many and speed matters, so they run cheap and fast. The supervisor is one, and its quality is the safety of the whole desk, so it is worth the more expensive call. And on a parse error it returns approve false. A broken checker rejects. It never waves a token through.

The Obsidian Vault: The Part Nobody Copies

Here is the piece that turns sixteen scripts with prompts into one desk. Every agent reads from and writes to one shared memory. When the book scores a narrative, it writes the outcome once the trade closes. When the rug checker kills a token, it writes the deployer signature. When a sniper eats a rug, the loss is written with the pattern that caused it.

The next launch reads all of it before a single model call fires. A deployer who dumped on three agents on Tuesday is rejected on Wednesday for free, because the vault remembers and the deployer filter runs first in the loop above.

Everyone building agent swarms rewrites the prompts and bumps the position size. Almost nobody touches the memory layer. That is the part that compounds.

Delete it and the desk still runs. The scanner scans, the snipers snipe, the rug checker checks. They just make the same mistake sixteen times, because nobody wrote it down.

The vault is not storage. It is the reason sixteen separate agents behave like one brain that remembers, and it is the only component here that gets better while you sleep.

Execution: Buying on the Curve

A buy on pumpfun is a Solana transaction against the bonding curve program. After graduation, trading routes through PumpSwap or Raydium via Jupiter. The snipers fire through Jito for priority inclusion, because on memecoins the entry window is measured in seconds and Jito is the difference between the early curve and the top.

There are no resting orders on a bonding curve, so the stop is not an order. It is price monitoring with an automatic sell on drawdown, running every few seconds on Grok Bot's persistent computer, around the clock, which is exactly the kind of dumb patient loop a cloud agent runs and a human cannot.

Grok Bot as the Orchestrator

You do not run this on your laptop. You describe the desk to Grok Bot and it runs the loop on its cloud computer, 24/7. It holds the wallet and the API keys, it scans and filters and scores and fires and writes to the vault. When a token scores high but a signal is borderline, it messages you and waits. When the loop throws an error, it tells you what broke and you fix it in the chat.

Persistence means the machine does not reset between sessions. The desk remembers which tokens it has seen, which it bought, which it skipped and why, and which deployers already burned it. That is working long-term memory, not a cold start every morning.

What Goes Wrong, and Why It Usually Does

Here is the half the "crypto bot" threads leave out.

The math of pumpfun is brutal and it does not care about your architecture. One to two percent of tokens graduate. Of those, most hand multiples to the earliest buyers and go to zero in the first hour after migration. The last buyer on the curve is exit liquidity for the creator and the snipers. This is not a bug. The bonding curve structurally rewards the first at the expense of the last.

Sixteen agents do not change that math. They filter faster and wider, they cut the obvious traps, they remember the deployers who burned you. They do not turn a one-percent task into a fifty-percent one. If the desk buys ten tokens a day and one graduates, you lost on nine. Whether the winner covers the nine is decided by position size, stop speed, and how early on the curve you landed. Nothing on this page removes:

MEV and frontrunning. Bots with mempool access see your transaction and buy ahead of it. Jito tips help and do not fully protect.
Rugs and dumps. A token can pass every metric and go to zero in five minutes because the creator pulled liquidity.
Speed of decay. A memecoin that does not build volume in the first twenty minutes usually dies. The desk must cut fast, not wait for a bounce.
Call cost. Every research evaluation is a model call. At thousands of launches a day, loose stream filtering can make the calls cost more than the tokens make.

The desk is a filter and a memory, not an oracle. Anyone selling you the oracle is the exit liquidity's exit liquidity.

Build Order

The order that catches each class of error at the cheapest stage.

Run the scanner and rug checker alone for a week with no execution. Watch how many tokens pass and what they look like.
Add the research ring and the score, keep execution off for another week, and compare your skips against the real fate of the tokens. This is where you learn whether the score predicts anything.
Turn on execution at minimum size, 0.01 to 0.05 SOL per trade, with every brake on. Collect real PnL, real slippage, real MEV.
Only after two weeks of real data, scale size, and scale it gradually.

Each stage catches its own failures. Paper scanning shows whether the filter works. Paper scoring shows whether it predicts. Micro-capital shows the real costs. Skip a stage and you are trading on hope, which pump.fun prices efficiently.

The desk is live. Every role, every edge, every fill is on the board.

Channel: https://t.me/miraqle_ai

GROKSTREET. 16 Grok Agents Flipping Solana Memecoins While You Sleep

Job breakdowns