v1.0Your own machine beside the chain: feeds, agent, and the fastest path

The research lab
for Solana quants.

Code: your agent builds strategies against every Solana feed

Paper: the same image on live data, every transaction simulated

Live: real transactions, the fastest path, one kill switch

Start building See the workspace

See the Lab

Built onSolanaYellowstone gRPCShredstreamUltrasendDockerClaude CodeCodex

mainnet-beta·slot 441,000,000

Three stages.
One machine.

Everything between an idea and a live strategy, on one machine beside the chain, in the order you’ll use it. Every panel here is live. Try them.

0103

[00]FeedsLearn more ›

Every feed, decoded and pre-wired

live

raydiumSwap { in: 259.5 USDC, out: 0.301 SOL }+1.7 ms
pumpfunTrade { sol: 3.01, side: buy }+2.1 ms
pumpfunTrade { sol: 2.96, side: buy }+1.8 ms
pumpfunTrade { sol: 1.74, side: sell }+2.4 ms
pumpfunTrade { sol: 1.42, side: sell }+1.3 ms
raydiumSwap { in: 227.8 USDC, out: 1.078 SOL }+1.3 ms

RPC, WebSocket, Yellowstone gRPC, the event stream and shreds arrive on your machine at sign-in as plain names on local ports. Subscribe to typed events, not account bytes; no keys to manage.

[01]CodeLearn more ›

Your agent has read your project

launch-momentum

#[strategy(subscribe = [pumpfun::Trade])]
pub struct LaunchMomentum {
    #[param(default = 45.0)] min_sol_in: f64,
}
impl Strategy for LaunchMomentum {
    fn on_event(&mut self, ev: Event, ctx: &mut Ctx) {
        ctx.buy(t.mint, Size::sol(0.5)).send();
    }
}

Claude Code and Codex run on your machine under your own subscription. Ask for a strategy and get a compiling image; work with the agent or by hand in the browser IDE and terminal.

[02]LiveLearn more ›

Runs in the rack, one click from paper

state

live

pnl · today

+4.11%

shred → strat

1.8 ms

kill switch · <100 ms

fra-1 · rack 3 · isolated container

Going live moves the same image beside the nodes that feed it, and every accepted transaction takes the fastest route. Monitoring, safeguards, and a kill switch that is always on screen.

One workspace, three stages.
The same strategy, start to finish.

Write it with your agent, paper-trade the exact image on live streams, then take it live beside the nodes. One image, one code path; only the mode changes. This is a working model of the workspace. Type to the agent, edit params.rs, and press the buttons.

auto-advancing · hover to pause · click to take over

lab / launch-momentum / code

connectedrust 1.89

rust · utf-8

1use quants::prelude::*;
2
3#[strategy(subscribe = [pumpfun::Trade, raydium::PoolState])]
4pub struct LaunchMomentum {
5    #[param(default = 45.0)] min_sol_in: f64,· edit in params.rs
6    #[param(default = 0.012)] take_profit: f64,· edit in params.rs
7    #[param(default = 0.006)] stop: f64,· edit in params.rs
8}
9
10impl Strategy for LaunchMomentum {
11    fn on_event(&mut self, ev: Event, ctx: &mut Ctx) {
12        if let Event::PumpfunTrade(t) = ev {
13            if t.sol_in_window(ctx, secs(30)) > self.min_sol_in {
14                ctx.buy(t.mint, Size::sol(0.5))· 1.8 ms shred → here
15                    .tip(Tip::Dynamic)
16                    .slippage(bps(80))
17                    .bracket(self.take_profit, self.stop)
18                    .send();
19            }
20        }
21    }
22}

agentclaude code

you

Pump.fun launches that reached Raydium within an hour over the last 30 days, followed by a momentum strategy on them.

assistant

mainbuild ok0 errors1 breakpointstrategy.rs · ln 14, col 17

[01]

Paper that tells the truth.
A distribution, not a promise.

Paper runs your exact image against live feeds, with every transaction simulated at the current slot: real fills against reconstructed pool state, charges for sends accepted into the path even if they later expire, and the trade someone else took first. Live submissions are charged once accepted into the transaction path; refused submissions are free. It is the same code and the same path you will run live; only a mode flag differs. Drag the sliders, change the seed count, and hide the naive line. A model that can't show you this would have shown you the dotted line.

live data: the same feeds live trading uses
fills: exact AMM math, reconstructed state
contention: modelled, flagged as counterfactual
one image: paper and live are one code path

Learn more

sim / launch-momentum / 30 d

seeds

landing rate72%

latency1.8 ms

fee multiplier1.00×

p10–p90 p50hover the chart to read a day · click “naive” to hide it

[02]

Runs in the rack.
Not across the city.

Going live moves the same image into your machine beside the nodes that feed it, and every accepted transaction takes the fastest route to the leader. A box elsewhere can't compete with that distance. Your keys live on your machine, created and held by you or your agent, and we never see them or touch what your code signs. Toggle the alerts, hover the latency bars, press Stop: it all works.

paper → live: one click, same image
kill switch: < 2 s to halt, always visible
alerts: fills, drawdown, errors, silence
custody: your machine, your keys

Learn more

deploy / launch-momentum

fra-1 · rack 3

state

live

pnl · today

+4.12%

shred → strategy

1.93 ms

fills · 24 h

61 / 84

latency · last 40 fills · hover a barp50 1.9 ms · p99 2.0 ms

alerts
isolation per-session Docker container · shared host kernel
keys on your machine · never ours

kill switch · always visible · <100 ms

0.0 ms
shred → strategy: co-located runtime, design target; 0
feeds on local ports: rpc · ws · grpc · shreds · send path; 0 s
kill switch to halt: refuses new sends in ms; 0.0 SOL
per month, to start: Pro 0.5 SOL · Max 2 SOL · Ultra 10 SOL

Built for engineers.
Your agent, your stack, your machine.

No SDK to learn and nothing to lock into. Every feed is a plain endpoint on a local port; write against it in any language that runs in Docker. Your own Claude Code or Codex does the building, on your machine, and you can pull all of it over SSH whenever you like.

One image runs in all three stages: Code, Paper, Live
Every feed on a fixed .lab.local port; no keys to manage
Rust and TypeScript templates, or any Docker image you bring
Full SSH and root. It is your machine, so export anything.

See the workspace

src/strategy.rs

rust · 1.89

1// the Rust template: tokio + solana-sdk, ready to run
2let mut sub = grpc.subscribe(PumpfunTrade).await?;
3while let Some(ev) = sub.next().await {
4    if ev.sol_in_window(secs(30)) > min_sol_in {
5        let tx = build_buy(&ev.mint, sol(0.05), Tip::Dynamic);
6        ultrasend.send(&tx.sign(&keypair)).await?;
7    }
8}

Security and custody.
Written down, not implied.

Real money runs through this, on your own machine. The posture is simple enough to state in three cards. Open one for the specifics.

Your keys never reach us

It is your machine. The keypair your strategy signs with is created and kept on it by you or your agent, and we never see it. The transaction path only forwards what your code has already signed; it never reads, holds or alters a key.

Nothing upstream is exposed

Every feed, the transaction path and the docs reach your code through plain local names such as rpc.lab.local and ultrasend.lab.local. Nothing else is exposed. Upstream hostnames, IPs, brands and credentials are rewritten out of errors, headers and docs. Your code and provider credentials stay on your machine. The control plane relays browser prompts and transcript events in plaintext at the application layer over TLS; that relay is not end-to-end encrypted from our infrastructure and its content is not intentionally retained.

One customer, one machine

Your machine is a single-tenant server. Nothing is shared with anyone else: not CPU, memory, or network. A live session runs in its own container with the safeguards you set. Stop is a hard kill switch, always on screen, and it refuses new sends in milliseconds.

Pick a machine.
Paid in SOL. Cancel any month.

Every plan is a dedicated machine beside the chain with the same feeds, the same transaction path, and your own agent ready. You pay more for more cores, memory, and disk, and a smaller cut of your wins. Everything is paid in SOL from a wallet you connect. No cards, no fiat, no invoices. Export your work before you go.

Pro

A first strategy, paper to live.

0.5SOL

/ month

·2 vCPU

·4 GB RAM

·40 GB NVMe

·Feeds included

·0.1 SOL AI credit / mo

·5% of profit on wins

Shared cores

Start on Pro

Maxmost machines

Serious research, room to run.

2SOL

/ month

·8 vCPU

·16 GB RAM

·100 GB NVMe

·Shreds included

·0.4 SOL AI credit / mo

·2% of profit on wins

Shared cores · shreds

Start on Max

Ultra

Latency-critical, dedicated cores.

10SOL

/ month

·20 vCPU

·48 GB RAM

·250 GB NVMe

·Shreds included

·2 SOL AI credit / mo

·1% of profit on wins

Dedicated cores · shreds

Start on Ultra

on every planthe difference is only the machine

Feeds: RPC · WSS · Yellowstone gRPC · event stream · StreamService, all on local ports with no keys to manage
Transaction path: Live submissions are charged once accepted into the transaction path; refused submissions are free. Charged from your SOL balance.
AI credit: a fifth of every plan, every month, for your agent; top up in SOL any time
Performance fee: a cut of the profit on winning live trades only (5% / 2% / 1% by plan); losing trades cost nothing
Your agent: Claude Code and Codex preinstalled. Sign in with your own subscription.
Workspace: browser IDE, terminal, and the Code · Paper · Live stages on one image
Access: full SSH and root on your own machine; open any port you like
Support: direct, from the people who run the machines

Enterprise

Dedicated hosts, multiple machines, custom feeds, and a private channel.

Talk to us

Live submissions are charged once accepted into the transaction path; refused submissions are free. Connect a Solana wallet, pay the month in SOL, top up any time; paper trading is free. Beyond the included credit, the agent can also run under your own Claude or Codex subscription, billed by them.

Questions.
Answered plainly.

No. Ask the agent in plain English and it writes, builds and runs the strategy on your machine. Templates ship in Rust and TypeScript; you can use any language that runs in a Docker container.

Start building on quants.sh
From 0.5 to 10 SOL a month.

Start building Read the docs

The research labfor Solana quants.

Three stages.One machine.

Every feed, decoded and pre-wired

Your agent has read your project

Runs in the rack, one click from paper

One workspace, three stages.The same strategy, start to finish.

Paper that tells the truth.A distribution, not a promise.

Runs in the rack.Not across the city.

Built for engineers.Your agent, your stack, your machine.

Security and custody.Written down, not implied.

Your keys never reach us

Nothing upstream is exposed

One customer, one machine

Pick a machine.Paid in SOL. Cancel any month.

Questions.Answered plainly.

Start building on quants.shFrom 0.5 to 10 SOL a month.

The research lab
for Solana quants.

Three stages.
One machine.

One workspace, three stages.
The same strategy, start to finish.

Paper that tells the truth.
A distribution, not a promise.

Runs in the rack.
Not across the city.

Built for engineers.
Your agent, your stack, your machine.

Security and custody.
Written down, not implied.

Pick a machine.
Paid in SOL. Cancel any month.

Questions.
Answered plainly.

Start building on quants.sh
From 0.5 to 10 SOL a month.