Pump.fun launched over two million tokens in the last quarter. The US stock market trades four thousand tickers with real revenue. One runs in seconds with no regulation, the other runs in hours with a century of it. Building a single bot that trades both is possible but stupid, the environments are too different. Building a team of specialized bots where each one does exactly one thing, across both markets, orchestrated by one brain that never sleeps, that is what this article builds.

Twelve bots. Four layers. Two markets. One Grok Bot running them on a persistent cloud computer around the clock. Not a toy demo with one LLM call. A complete trading desk where crypto bots and stock bots run independently, a capital allocator decides how much budget each side gets based on market regime, adversarial checkers veto bad trades on both sides, and an exit manager actively manages every open position every day.

Why Alpaca and not Robinhood directly? Robinhood has no public API for bots. Alpaca was built API-first: commission-free, paper trading free, bracket orders in one call. Everything here applies if Robinhood ever ships an API. The code runs on Alpaca because the code needs to work.

The four-layer architecture

Most trading bots are a single loop: find, evaluate, buy. This system has four independent layers, each running on its own schedule.

Every bot runs independently. The scout does not wait for the analyst. The insider tracker does not wait for the narrative scorer. They produce scores, deposit them in a shared state, and the scoring matrix reads whatever is available. This means a crypto trade can happen at 3 AM while the stock side is asleep, and a stock trade can happen at 10 AM while the crypto side is busy filtering a burst of launches.

Layer 1: intelligence bots

Bot 1: the scout (code, crypto, 24/7)

WebSocket connection to pump.fun, filters the stream by metrics. No LLM. This bot runs continuously and never sleeps.

Bot 2: the auditor (Grok fast, crypto)

Analyzes wallet behavior beyond what metrics show: coordinated buys, wash trading, creator dump preparation.

Bot 3: the narrative scorer (Grok fast, crypto)

Evaluates meme potential: trend fit, virality, community, timing. The one thing a script cannot do.

Bot 4: the stock screener (code, stocks, daily)

Runs at 9:35 AM ET. Surfaces up to twenty candidates from a watchlist.

Bot 5: the deep analyst (Grok fast, stocks)

Combined fundamental and technical analysis for stocks.

Bot 6: the news radar (Grok fast, stocks)

Reads headlines, Twitter/X, Reddit, analyst moves. Separate signal from the analyst: numbers vs what people are saying.

Bot 7: the insider tracker (Grok fast, stocks)

SEC Form 4 and 13F filings. When the CEO buys two million with their own money, that signal beats every indicator.

Layer 2: context bots

Bot 8: crypto pulse (Grok fast, cached 15 min)

Evaluates the crypto market, not individual tokens. If SOL is dumping, do not buy memecoins.

Bot 9: market pulse (Grok fast, cached 30 min)

Evaluates the stock market. If VIX is spiking, do not open longs.

Bot 10: the capital allocator (Grok fast, daily)

This is the bot that makes the system smarter than two independent pipelines. It decides how to split the daily budget between crypto and stocks based on which market is hotter right now.

The allocator is what makes twelve bots a system and not just two scripts taped together. When meme season is hot and stocks are flat, it shifts eighty percent to crypto. When crypto is dead and stocks are rallying, it shifts the other way. When both are cold, it keeps cash, which means tight position sizes on both sides.

Layer 3: decision bots

Bot 11: crypto checker (Grok full)

Adversarial for crypto trades. Gets all crypto agent outputs and looks for reasons not to buy.

Bot 12: stock checker (Grok full)

Same pattern, different questions. Looks for overvaluation, earnings risk, sector headwinds, insider red flags.

Layer 4: the exit manager

One bot manages ALL positions across BOTH markets. It runs at least twice daily: once at stock market open (for overnight gap assessment) and once before close (for end-of-day decisions). For crypto it runs every four hours.

The exit manager is market-agnostic: it reviews crypto and stock positions with the same logic, just different market context. A memecoin held for two hours with minus thirty percent PnL and a stock held for three days with minus five percent PnL get different treatment, but from the same bot with the same framework.

Risk management: portfolio level

Cross-market constraints: total open positions capped, crypto and stocks capped independently, sector concentration for stocks, and a single daily loss limit across both markets. If crypto burns the daily limit, stocks stop too.

The orchestrator

Four concurrent loops via asyncio.gather. Crypto runs continuously. Stocks run on market schedule. Exits run every four hours. The allocator rebalances daily. All independent, all writing to the same log, all sharing the same risk manager.

What this costs

At twenty stock candidates and fifty crypto tokens passing the filter per day:

Crypto: 50 auditor (fast) + 50 narrative (fast) + ~5 checker (full) = ~105 calls Stocks: 20 analyst + 20 radar + 20 insider (fast) + ~3 checker (full) = ~63 calls Context: crypto pulse ~96/day + market pulse ~16/day + allocator 1/day = ~113 calls Exits: ~10 position reviews (fast) per cycle, 6 cycles = ~60 calls Total: ~341 calls/day

At three cents per fast call and ten cents per full call: ~$9/day, ~$270/month. That is the cost of the intelligence layer. Whether it earns more than $270/month determines whether the system is worth running.

What can go wrong

Cross-market correlation. In a real crash, crypto and stocks drop together. The capital allocator shifts budget, but there is nowhere safe to shift to. Cash is the only hedge, and the allocator should output low allocations for both when everything is falling. Allocator lag. The allocator runs daily. A regime change that happens mid-day will not be reflected until tomorrow. The pulse bots partially cover this with their cached 15/30 minute windows, but a flash crash moves faster than any cache. Exit manager overtrading. If the exit bot says TRIM or CLOSE too often, you churn through positions. Track its action frequency and penalize excessive activity. Agent cost exceeding PnL. Three hundred plus calls a day is real money. If the system is not profitable, tighten the screener and scout filters to reduce the number of tokens and stocks reaching the LLM layer.

Build order

Phase 1 (week 1-2): scouts and screeners only, no LLM, no execution. Log what they surface and check manually.

Phase 2 (week 3-4): add all LLM agents. Log scores, do not trade. Compare agent recommendations against actual price moves.

Phase 3 (week 5-8): paper trading on both sides. Crypto on dry-run, stocks on Alpaca paper. Run the exit manager. Four weeks minimum.

Phase 4 (week 9+): real money, smallest sizes. Scale only after two months of positive paper PnL.

Repository and sources

Full implementation: github.com/zostaff/grok-trading-desk My telegram channel: https://t.me/zostaffsmartarc

The transaction executors for both markets are stubs. Code that moves real money is worth writing and reading yourself.

Grok Agents x Pump.fun x Robinhood: The 12-Bot Trading Desk Blueprint

Job breakdowns