EyezOn Stack Scan
Recent OSS / tooling that actually fits our context · curated hard · 22 Jul 2026
★ Top 5 for us
Free public WS streaming every pump.fun / bonk.fun token creation, migration & trade in real time — wss://pumpportal.fun/api/data.
For us: kills the 90s polling gap for pre-grad discovery. subscribeNewToken + subscribeMigration are free, no key, ~10 lines of Python. Fastest possible win on goal (a) — we hear about a mint the instant it exists, not a minute later.
FREE (trades metered)drop-inPython WS
Cheapest credible geyser streaming: typed accounts/txns/slots over gRPC, sub-50ms, Jito ShredStream on by default. From $49/mo (1 stream); free tier ~25 RPS.
For us: the real "own the data" path (goal b) — one gRPC feed replaces rate-limited GeckoTerminal/DexScreener/Birdeye polling for live swaps & new-pool events. ShredStream = see txns pre-confirmation. This is the Iris/Retina backbone. Helius LaserStream is the drop-in-compatible premium alt.
$49/momoderate → bigYellowstone gRPC
Rust frameworks that turn a raw geyser stream into typed structs. Carbon ships 40+ pre-built decoders (pump.fun, Raydium, etc.); Vixen is a parser+handler pipeline toolkit from Triton.
For us: don't hand-roll DEX swap parsing — these give production-grade decoders so we go stream → typed swap → our candle/indexer fast. Directly accelerates the own-candle engine. Cost is Rust (our stack is Python), so it's a bigger lift — but it's the exact thing our data engine needs.
FREE / OSSbig (Rust)indexer framework
4Claude prompt caching + model routing
Mark stable prompt prefixes cacheable (cache-read ≈10% of input); route trivial calls to Haiku 4.5 / Batch API (-50%). Documented 60-90% bill cuts.
For us: pure efficiency win (goal d) on the agent swarm — cache the big standing briefs/CLAUDE.md context, send classification/triage to Haiku, keep Opus for reasoning. No quality tradeoff, mostly config. Load the claude-api skill before wiring.
config onlydrop-inLLM cost
5DuckDB + Parquet (analytics tier)
Embedded columnar DB that queries Parquet/Arrow directly. Reports that time out at 90s in SQLite run in ~4s.
For us: two-fer — (1) relieves our database is locked pain by moving heavy analytical reads off the SQLite writer (SQLite = hot writes, DuckDB = OHLCV/leaderboard/backtest reads over Parquet); (2) proper time-series store for the candle history. Adopt alongside SQLite, not instead.
FREE / OSSmoderatetime-series
1 · Real-time Solana ingestion — highest value
Feeds faster discovery (goal a) + owning the data (goal b). Ranked #1–3 above live here too.
Yellowstone-compatible gRPC with historical replay, auto-reconnect, multi-region; Shred Delivery for raw pre-confirmation shreds.
For us: premium alt to #2 if Chainstack latency isn't enough — LaserStream is drop-in Yellowstone-compatible so no rewrite to switch. We already have Helius keys on file, so it's the low-friction upgrade path.
paid (have keys)drop-in vs #2
Python examples + clients for subscribing to a Yellowstone/Jito geyser stream from Python.
For us: the bridge that keeps us in Python — consume the gRPC feed without going full Rust. Start here for a first geyser proof-of-concept before deciding if Carbon/Vixen is worth the Rust jump.
FREE / OSSdrop-in (Python)
Honest take: the trading/sniper-bot repos (Trading-API, Raydium sniper bots) that keep surfacing are execution tools, not data infra — skip for our use. The real pattern: PumpPortal WS now (free, instant), then graduate to our own Chainstack/Helius geyser feed as the durable "own the data" layer.
2 · On-chain analytics / forensics
Mostly reference implementations to save build time on holder/bundle/PnL — not services to depend on.
TS lib scoring rug risk from metadata, top holders, LP, mint/freeze authority.
For us: clean reference for the holder-concentration / authority checks in our scoring matrix (goal c). Mine the heuristics, don't necessarily adopt the code.
FREE / OSSreference
Python utils that batch Helius-enhanced txns, classify BUY/SELL, aggregate per-mint PnL for a wallet's pump.fun / Raydium Launchpad trades.
For us: closest match to our whale-DB PnL work and it's already Python + Helius (our stack). Good scaffold for wallet P&L ranking in the Whale DB.
FREE / OSSPython + Helius
RugCheck's risk API (widely used standard) + an MCP wrapper so an agent can call it.
For us: the MCP server is a fast cross-check signal our swarm could call directly; RugCheck itself is a sanity benchmark to grade our own matrix against. External dependency though — treat as a bridge, not truth.
free tierMCP drop-in
Caution: a cluster of "Solana wallet analytics Telegram tool / top-100 pump.fun wallets" repos are common credential-honeypots. Don't run them; read the technique only. We own this forensics layer already — these just de-risk edge cases.
3 · AI agent workflow + reliability
For swarm reliability (goal e) + Pete's harness-engineering interest. Curated to what helps a Claude-Code swarm.
Living index of agent-harness tooling: observability, evals, memory, MCP, permissions, orchestration.
For us: the single best map for hardening our swarm — evals, guardrails, context-compaction patterns. Read once, cherry-pick. Matches our own coordinator/verifier/one-owner-per-file discipline.
FREE / OSSreading
Anthropic's own guidance on eval-driven agents; server-side compaction cut tokens 84% in a 100-turn eval.
For us: compaction directly cheapens our long-running loops (dovetails with #4); the evals playbook is how we stop re-fixing the same swarm failures — turn recurring misses into a regression gate.
first-partyconfig/pattern
Honest take: most "10 agent frameworks" (LangGraph, TaskWeaver, etc.) are for teams NOT already on Claude Code — we'd be trading our working harness for a lateral move. Skip the frameworks; take the patterns (evals, compaction, structured permissions) into our existing setup.
4 · LLM usage optimisation
Prompt caching · Batch API · Haiku routing
Cache stable prefixes (-90% on reads), Batch API (-50%), route trivial work to Haiku 4.5 (~$0.25/M in). See #4 above.
For us: the biggest, safest cost lever — no model quality hit, mostly config. Cache the standing briefs; batch non-urgent scoring.
configdrop-in
Ultra-fast open-model inference: Groq from $0.05/M (Llama 8B), ~750 tok/s; Cerebras ~2,100 tok/s; Kimi K2 ~$1/M on Groq. Free tiers exist.
For us: only for narrow high-volume subtasks — e.g. yes/no token classification, ticker/metadata extraction, matrix pre-filtering — where an open model is fine and speed/cost matter. NOT a Claude replacement for reasoning. Adds a second provider to maintain, so use surgically.
free tier + cheapmoderateopen models only
5 · Efficiency / infra
DuckDB + Parquet
Columnar analytics engine over Parquet; see #5 above.
For us: splits hot SQLite writes from heavy analytical reads → fixes database is locked + gives a real OHLCV time-series tier.
FREE / OSSmoderate
WAL mode + funnel ALL writes through one dedicated writer thread/queue; Litestream for continuous replication/backup.
For us: the cheapest immediate fix for database is locked if we stay on SQLite — a single write queue removes the contention entirely, no new infra. Litestream adds streaming backups on Railway for near-free. Do this before reaching for DuckDB if the lock is our only pain.
FREE / OSSdrop-in pattern
Sequence: (1) WAL + single-writer queue kills the lock error this week; (2) DuckDB/Parquet tier when analytical reads grow; (3) geyser feed to own the source data. Each stands alone — ship in that order.