Three weeks ago I published the full setup of my Grok Bot desk that made me 6 figs. Read, this one sits on top of it and does not repeat it.

What this adds: every judgement on the desk is now a typed number with a probability on it, instead of prose my code had to parse.

Now a collector pulls every FOMO token with its metrics, the chain data for whatever chain it lives on, and the project's X account. Jev answers typed questions about each one, then makes one final call: which of these do we trade. Grok Bot trades the token Jev picked.

ADVICE: PASTE THIS ENTIRE GUIDE INTO YOUR CODING AGENT AND TELL IT TO BUILD THE DESK

Below: every file paste ready.

Before you started reading this setup guide dont forget to follow @savipww..

Trading here: FOMO

All alpha here: Telegram

What you need first

Six things. Each one says what it is, what you do with it, and why the desk needs it.

1. A Jev key

What it is. TypeSafe came out of stealth September 15, $40M led by DCVC, founder co-wrote the InstructGPT paper. Jev does not generate text at all. You send it state and typed questions, it sends back typed answers with probabilities in 70 to 500ms.

What you do. Sign in at console.typesafe.ai, open Keys, create one, copy it the moment it appears because you will not see it again. Put it in your environment:

Why. One service on the desk holds this key and calls this endpoint. No bot ever sees it.

Before anything else, prove the key works. One curl, and you will never again confuse abad key with a bad question:

2. The three question types

What they are. The entire API. Every question the desk asks is one of these three, and you will see them in every file below.

What you do. Nothing yet, and nothing by hand once it runs.

The playground is a one time thing while you are writing questions: drop any token in as the state, ask your question, watch the probabilities move as you reword it. A question is a prompt and it has the same failure modes as a prompt. Once the wording is right it goes into questions.py and you never open the playground again.

In production nothing is pasted anywhere. collect.py pulls fresh pools from GeckoTerminal, metrics from FOMO twenty at a time, trade counts from DexScreener and the contract data from the chain, then builds the state and sends it. You log into FOMO in Chrome once, and that is the only manual step in the entire desk.

Why. noul is an if, choice is a switch, score is a sort. Your code reads the number, the threshold decides, nobody reads a paragraph.

The split you have to hold onto. Jev takes the judgements. Code takes the arithmetic. Every number on the desk is computed before the call and passed in as a field.

3. The SDK

What it is. The Python client for that endpoint.

What you do. One command:

Why. judge.py imports AsyncTypeSafeClient from it and questions.py imports Choice, Noul and Score. Without it both files fail on their first line.

4. A FOMO session

What it is. Where the token universe comes from. FOMO has no public API, so the collector reads your own logged in session.

What you do. Log into FOMO in Chrome and leave that profile alone. The bearer lives about an hour and the client refreshes it from the browser on its own.

Why. This one call returns every metric the free pass needs, twenty tokens at a time, so hundreds of candidates cost you one request instead of hundreds.

5. Chain data

What it is. GeckoTerminal, free, no signup, no key.

What you do. Nothing to set up. Just hold onto one number: 10 calls per minute.

Why. That limit is the shape of the entire funnel. Six calls list fresh pools across three chains, which leaves three dossiers per cycle, which is why everything above the dossier has to kill hard.

Read this table before you write a single question. The desk trades Solana, BSC and Robinhood, and they do not hand back the same fields. I called all three on September 23:

So each chain gets its own question set, routed in code. Solana gets getTokenLargestAccounts and getTokenSupply off the public RPC for free. Robinhood's own RPC is rpc.mainnet.chain.robinhood.com and answers 403 without a browser User-Agent. Etherscan V2 is one key for 60+ chains via ?chainid=, but topholders, tokenholdercount and tokeninfo are all PRO and none of them cover Solana or Robinhood. Worth buying if you trade mostly BSC, and it drops into the dossier step without changing a single question.

6. The desk itself

What it is. The six Grok Bot seats from the original guide, plus the venue they fill on.

What you do. Nothing new. The seats already exist, they just get their token from a different place now. The project's X account is read by Grok Bot's own X plugin, and the handle comes off chain rather than from a search, so no bot goes hunting for "the project's Twitter" and finds a fan account.

Why. Fills go through FOMO and nowhere else. One venue, one execution path, so a bad fill is always traceable to one place, and the referral discount applies to every trade including the ones your bots place.

Each pass is more expensive than the one above it, so each one has to kill harder than the one below. The free cut touches no network at all: everything it reads arrived with the FOMO batch. Only what survives it is worth a DexScreener call, and only what survives that is worth one of your three dossier slots.

The files

Seven files and four prompts. Build them in this order, top to bottom.

0. JUDGE

Save as judge.py. It runs on one machine, holds the only Jev key, and makes no trading decision of any kind. Bots get a desk secret and never the key itself.

Rules baked into those forty lines:

1. SCAN and VET: the collector

Save as collect.py. Jev fetches nothing, it is a function, so this is the code that goes and gets everything. SCAN runs universe and shortlist, VET runs dossier.

And the client every seat uses to reach the judge. Six lines, and it is the only place a bot touches the network for a judgement:

2. QUESTIONS

Save as questions.py. judge.py imports SETS from it, and this is the one file you will actually reread later. Every question the desk can ask lives here and nowhere else.

Four rules that make this file work:

3. THE FILTER

Two files: thresholds.py and filter.py. The first holds every number, the second holds the order they fire in. When you retune the desk, you edit thresholds.py and nothing else.

The order is the whole point. free_kill touches no network and runs on hundreds. trade_kill costs one DexScreener call and runs on tens. chain_kill costs one of your three GeckoTerminal slots. soft_kill costs a judgement and runs on a handful. Facts kill before judgements do, which is why authority_open and honeypot are comparisons here and not questions in questions.py. You ask Jev how dangerous the concentration is, and the comparisons handle the plain facts.

Log every rejection with the check that fired. Under ten rejections a day and your filter is misconfigured, not your market.

This is a prompt, not a file. Paste it into the SOCIAL bot. It took BOOK's chair, and it exists because Grok Bot ships with an X plugin that reads. Grok reads, Jev judges.

The handle comes off chain and is already normalised by the collector. Never let this seat go searching for "the project's Twitter", it will find a fan account and be confident about it. No handle means no social read, and the token carries that as a gap rather than a pass.

recycled_account is the highest value question in the whole file. It holds two timelines side by side, the account's and the token's, and hands you one number for the gap.

5. PICK

Save as pick.py. CHIEF runs it, and it is the only call that ever sees more than one token at a time. A Choice takes up to 255 options and your shortlist is never longer than ten, so the whole decision fits in one request.

No trade is a result. Log it with the reason, send it to Telegram, and stand down until the next run. A desk that trades every cycle is a desk with no filter.

6. THE HANDOFF

Paste this above the prompt of every seat that makes a judgement: SCAN, VET, SOCIAL and CHIEF. It is what removes the bot's own opinion from the loop.

Record one judge call by hand in front of Grok Bot and save it as a skill. Skills are shared across every bot on the desk, so you paste this once instead of six times.

Prove the link from a bot's own terminal, not from your laptop. Passing on your machine and failing on theirs is a firewall problem and it is how this setup dies quietly.

answers.shape.choice must be one of your options, probabilities must sum to 1, model must be a version string and not an alias. If any of the three is off, stop here.

What CHIEF drops into the desk channel when the pick comes back. This is the whole handoff, and the bots work it top to bottom:

7. SIZE, FILLS, RISK

Three prompts, one per seat. Nothing to install. These are unchanged from the original guide, except the ticker now arrives from the pick and carries a size_factor with it. No judge call between the three of them, and no key.

The exit is a single comparison on two numbers the desk already holds, so it runs the instant the data lands and it runs the same way every time. That is what you want in the seat that closes.

Jev picks what to hold. Grok Bot decides how much and how long. The exit rule answers to neither of them.

8. THE BOOK

Save as book.py. It creates desk.db on first run, nothing to set up. Two things the desk has to remember between cycles, and skipping either one costs real money.

One position at a time. The cycle runs every fifteen minutes. Without a guard it picks a second token while the first is still open, then a third, and by evening RISK is trying to manage a portfolio nobody sized. While a position is open, the scan does not run at all.

A rejected token stays rejected for a while. A token that failed at 10:00 is still the same token at 10:15. Without a bench it burns a GeckoTerminal slot and three judge calls every cycle until it ages out. And the bench is not one length: a honeypot flag will never become false, but too early to tell becomes tellable within the hour.

9. THE SHIFT

Save as main.py and run it. This is the process that never stops: it owns the cycle, calls everything above in order, and hands finished orders to the seats. Start it with shadow=True and leave it that way for a week.

The budget is the design. GeckoTerminal gives you ten calls a minute, six of them go to listing fresh pools across three chains, so three dossiers per cycle is what is left. That is why the free pass has to kill hard: by the time a token reaches a dossier it has already survived everything a comparison can do. Want more dossiers, cut pages to 1 and you get six.

Failure handling, because this runs unattended:

Run it with shadow=True for a week. It does everything except send the order and take the book, and desk.log_shadow writes one row per would-be trade: the ticker, every answer with the model id, the rejection counters, and what your old logic did with the same candidates. Read only the rows where the two disagree. That is twenty minutes each evening and it is where your thresholds come from. Then flip the flag.

One more thing that bites unattended runs: the FOMO bearer lives about an hour. main calls fomo.token() at the top of every cycle so the client can refresh it out of Chrome before the batch goes out, rather than discovering it expired halfway through a funnel.

The bill

State is charged once per call, output is free.

The rate limit upstream caps this for you. Three dossiers a cycle means at most three tokens reach the judge, and each one takes three calls (market, chain, social) plus one pick over the survivors. Ten calls, roughly 1,400 input tokens each:

Under six cents a day for every judgement the desk makes. The DexScreener and GeckoTerminal calls that feed it are free, and the only thing you actually pay for besides this is the SuperGrok plan the bots already run on.

Split any set into one call per question and you pay three to four times that for identical answers, because the state gets charged again each time. That is the whole reason questions.py groups them into sets instead of exposing them one at a time.

IMPORTANT PART:

This is my setup, not your strategy!!!

Every threshold above is mine, tuned against the launches I trade, over one week, on my bank and my risk tolerance. Run it in shadow mode first: log every answer next to what you would have decided yourself, and move the number where you disagree. Copy the shape, not the constants! NFA and Always DYOR!

Code fetches, the model judges, code decides. A seat that computes does not get a judge call. A seat that judges does not get a calculator.

The full desk this sits on top of: the original setup guide! (six figs was made using this guide)

Thanks for reading and supporting, we will never stop <3

FOMO: fomo.family/r/savipww Telegram: t.me/+GrPfolvACZg2OTMy

Megabrain (Jev) & Six Grok Bots That Already Made Me Six Figures (Setup Guide)

Job breakdowns