Tool reference

Backfill OHLCV into the catalog. Asynchronous — returns a job_id.

The worker handles Coinbase's 300-candle-per-request limit by chunking with backoff. For 1-minute history prefer a bulk CSV; the API is for recent top-up, not for pulling a year 300 bars at a time.

List datasets with summary stats, deepest history first. Never returns bars.

The ordering is load-bearing, not cosmetic. An agent asked to pick a dataset takes the first one, and this used to sort by timeframe NAME -- which is alphabetical and says nothing about usefulness. On BTC-USD that put "1d", holding 46 bars, ahead of "1h", holding 93,819 over ten years. Both are real timeframes; the daily series is simply thin. But a caller who takes the head of the list lands on 46 bars, registers a split, spends trials, and is told only at the gate that the series is too short to conclude anything from.

Depth is what makes a dataset usable, so depth decides the order. Nothing is hidden -- a short series is sometimes exactly what is wanted, and callers who know which timeframe they need should pass it.

Gap accounting, OHLC structural violations and per-source lineage.

The checks are cheap and catch vendor corruption immediately: high below low, close outside the bar's range, duplicated or non-positive prices.

Choose how gaps are handled in backtests on this dataset.

There is deliberately no forward_fill. Forward-fill fabricates flat bars, suppresses realised volatility and triggers phantom signals.

'skip' used to zero the return of the interval spanning a hole. That was wrong in the direction that flatters a strategy: a position already on at the pre-gap open cannot be flattened inside the outage without lookahead, so the gap move IS earned by whatever was held, and zeroing it deleted real drawdowns from the equity curve. With opens [100, 100, 70, 71] a constant long booked 0% across the hole instead of -30%.

That interval is now priced like any other under both policies, which leaves 'skip' with no effect on P&L. Both settings still record gap_count in the quality report and mark gap bars untradable. The option is kept because splits freeze the policy in force when they were registered, so older splits must still name the value they were created with.

Resample time bars onto activity, and report whether it actually helped.

Time bars sample on a clock the market does not follow: activity arrives in bursts, so quiet periods are oversampled and busy ones undersampled. The resulting fat tails break every normality-based Sharpe statistic — a return kurtosis of 18 makes the usual inference meaningless. Dollar and volume bars sample on activity instead.

The comparison is returned rather than assumed, because resampling does not always help and claiming it did would be its own kind of lie.

Register train/validate/test/holdout ranges. Immutable once created.

Registering the split before you look at any result is what stops 'out-of-sample' from being redefined after the fact. The holdout range is stored but its bars are not readable through any tool except holdout_evaluate.

Backfill a basket of instruments and register it as a universe.

Testing one spec across many instruments is the only way to genuinely increase effective sample size. Resampling the same history to a finer grid adds autocorrelated bars, not information, and does not lower the deflated Sharpe hurdle — which is denominated in years, not observations.

Registered baskets and their measured breadth.

Takes no parameters.

Run one spec across a whole universe. Adds exactly ONE trial to N.

The spec is the hypothesis and the assets are the sample, so charging one trial per asset would penalise the statistically correct thing. Returns the cross-sectional Sharpe distribution plus a pooled estimate whose standard error uses M_eff — the effective number of independent tests — rather than the raw asset count.

How many independent tests a basket actually provides.

Crypto co-moves. Thirty assets are not thirty confirmations, and booking them as such would replace one overfitting mechanism with another.

Pin the current fee tier server-side.

The caller cannot supply fee assumptions anywhere in this server. Whatever this returns is stamped onto every run that follows.

What the edge must clear before any signal is worth discussing.

Call this before designing a strategy. If the required edge per trade exceeds anything plausible at your intended frequency, the frequency is wrong and no signal will fix it.

Register a strategy spec. Identity is the sha256 of the canonical spec.

The spec is a small declarative graph — named features with explicit lags, plus entry/exit predicates — precisely so feature_validate can analyse it for look-ahead. Arbitrary Python could not be checked.

Static look-ahead analysis of the feature graph.

Catches the most common backtest lie before it costs a run: negative lags, forward-looking ops, and statistics fitted over the whole sample. A feature reading close[t] is fine here because execution is next-bar-open and the server enforces that.

Lock the spec, pinning a parameter vector into it. Irreversible.

Required before the holdout and before any paper session. Freezing forces you to commit to one configuration rather than deciding which one you meant after seeing the holdout.

Start a new trial-counting family, recording why.

Strict accounting: a fork does not reset N. The lineage is walked when N is computed, because you did learn from the parent's trials. The justification is stored in the ledger so the reset is auditable rather than silent.

Documented strategy hypotheses with an economic rationale.

The reason this exists: a parameter search has no prior, and a search without a prior finds whichever configuration traded least in a rising market. Every entry here states who is on the other side of the trade and why they lose, so a result can be judged against a hypothesis rather than a curve fit.

Citations are model-generated leads to check, NOT evidence. `citation_verified` is false until a human has actually looked the source up.

The full entry: rationale, origin, failure modes, and the falsification test.

Register a library hypothesis as a strategy in your own family.

This is the point of the library: the idea enters the ledger with a recorded provenance, so a later result can be traced to the hypothesis that motivated it rather than to a sweep that found it.

Documented strategy failures, with the mechanism and what would have caught it.

Companion to the strategy library: that gives hypotheses with a prior, this gives failure modes with a mechanism. Useful when a result looks good and you want to know which known way it might be wrong.

Sources are model-generated leads and are NOT verified.

The full record for one documented failure.

Queue a backtest. Adds exactly one trial to N.

Execution is next-bar-open and enforced server-side. Costs come from the latest pinned cost model; there is no fee parameter.

Queue a parameter sweep. Every point is a trial.

The updated N is returned immediately, before any result arrives, so the statistical cost of the sweep is visible while you can still cancel it. Sweeping 2,000 points to find a winner shows up as N=2000 in every deflated Sharpe you compute afterwards.

Poll a submitted job.

Fetch the metric summary for one recorded run.

Around twenty numbers, never a trade blotter. Gross and net sit side by side so fee drag is impossible to overlook. The full return series is available as a resource at quant://runs/{run_id}/returns.

Deflated Sharpe for one run, against the family's trial count.

N is read from the ledger. It is not an argument, and cannot be.

Stationary-bootstrap confidence intervals for Sharpe and expectancy.

A point estimate from a few dozen trades is not a measurement. Expect the interval on a marginal strategy to include zero; that is the tool working. Block length respects serial dependence, so the interval does not inherit the false precision an iid bootstrap would give.

Queue combinatorially symmetric CV to measure overfitting probability.

Asks whether the configuration that looked best in-sample tends to land above or below the out-of-sample median. Above 0.5 means your selection procedure is anti-predictive. Uses the family's evaluated parameter vectors unless you pass a grid; the re-evaluations are recorded but deliberately excluded from N.

Queue White's Reality Check, Hansen's SPA and Romano–Wolf on a family.

Tests the best member against the whole family it was selected from, using a stationary bootstrap that preserves serial dependence. Testing the winner in isolation answers a question nobody asked.

MinBTL = 2·ln(N) / E[max_N]² — how much data N trials actually require.

Frequently the tool that ends a line of research early, which is the point.

The audit trail: N, the Sharpe distribution, and the extremes.

Read-only, and append-only underneath — N can never be revised downward.

Label every candidate entry by which barrier it would have hit first.

A strategy that trades twenty times in two years cannot be evaluated. This scores each potential entry against a profit-take, a stop and a time limit, which enlarges the evidence base without increasing trading frequency — the central tension in this system.

When both price barriers fall inside one bar the stop is taken: a bar cannot resolve which was touched first, and the adverse assumption is the only one that does not flatter the result.

Run the statistical gauntlet. Passing is what unlocks the holdout.

Seven checks, including the Harvey–Liu t > 3 hurdle rather than the conventional t > 2, and regime survival tested separately in bull, bear and chop rather than in aggregate.

Spend the one holdout attempt for this frozen strategy.

Requires the strategy to be frozen and gate_check to have passed against that exact spec hash, with no prior grant. Every attempt is logged whether or not it succeeds. There is no second attempt, ever.

Pass dry_run=true to check every precondition and see what would happen without spending the grant or logging an attempt. A tool this expensive should be inspectable before it is fired.

Make the newest gate_check verdict on a strategy readable without an account, at a public URL -- or take it back with public=false.

The page shows the strategy's name and family, the split and data it was judged on, every check with its value and hurdle, and the ledger's trial count. It never shows the spec or its parameters. Reversible; the row is the tenant's own and RLS decides that.

Queue an event-driven revalidation with honest fill modelling.

Resting post-only limits fill only when the bar actually trades through the level, capped by volume participation, and are cancelled unfilled after max_wait_bars. A resting order that never fills is simulated as never filling — assuming fills at the touch is the second-most-common backtest lie after understating costs. Does not add to N: it revalidates an existing trial rather than creating a new one.

Forward-test a frozen strategy on bars that did not exist at build time.

The only validation that cannot be overfit. 'start' opens a session against a frozen spec, 'record' evaluates newly printed bars and logs signals, 'report' summarises forward performance after the pinned cost model.

What this server is, what it holds, and what has changed recently.

Call this first in a new conversation. It is cheaper than rediscovering the state by trial and error, and it will tell you which research lines are already closed.

Takes no parameters.

Whether this account can place real orders, and what still stops it.

A new account is PAPER. Paper orders are recorded and reach no venue, which makes them the cheap default rather than a consolation.

Every venue this server knows: Coinbase (native) plus Kraken, Binance, Bybit and OKX (via ccxt). Paper runs work on all of them; LIVE trading is Coinbase-only. `configured` says whether this server holds keys for it.

Takes no parameters.

Available balance per currency on one venue, read from the venue's own books. Needs API keys for that venue on the server; read-only.

What a market order WOULD look like: the product it routes to, the price, the taker fee and where that fee came from, and anything that would stop it. Coinbase uses the venue's own order preview (its commission is the fee you would pay); other venues use ccxt's published schedule. Never places, edits or cancels an order on any venue.

What the meme-coin launch collector has gathered: launches, graduation rate, curve polls, post-graduation marks, creator wallets. Shared data, collected from free public sources since the collector first ran.

Read the base rates first. Graduation is rare and survival after it rarer; a launch-time model that ignores that is the meme version of funding luck.

The newest launches that graduated to an AMM, with their curve at +2/10/30/120 minutes, the creator's prior record, and the AMM price at fixed offsets afterwards. The raw material for a graduation-momentum or creator-reputation hypothesis -- to be registered and gated like any other.

pump.fun coins by stage, from the chain only: the newest launches (with the creator's earlier launches and graduations), the bonding curves nearest graduation (curve_pct, the SOL in the curve), the graduations of the last two hours (minutes on the curve, instant or not) and the deaths of the last two hours (a curve gone quiet, a pool drained). Built at most every 5 s for everybody. `status` says which stage is live and why one is not.

One coin's moments, from the chain only: its launch (block time, the creator's wallet), the creator's own buy, a bundle in the launch's slot, the creator's first sale, big trades, its graduation to PumpSwap and its death; the time it spent on the curve, whether it graduated instantly, and the creator wallet's age. {"found": false} for a coin our launch records do not have. `recorded` says whether its curve and its pool were watched; `unavailable` names the moments that cannot be known for it.

A coin's price in SOL from its launch to now, from the chain only: its bonding curve (curve_pct beside each point) and, after graduation, its PumpSwap pool, cut to max_points keeping every bucket's high and low. `gaps` says where the line is not recorded and why; {"found": false} for a coin our records do not have.

The graduates of the last `hours` whose PumpSwap pool ran furthest, measured from the first pool price at least two minutes after graduation (the earliest a real buy fills), one row a coin, best first, from the chain only. Each row: the peak multiple and when, how long the price held near it (`spike` = a peak no seller could have caught), and the multiples one and six hours after graduation (what a holder really saw). Coins whose pool was not recorded are listed apart with the reason. Research lock until 2026-11-09: per-coin facts only, never a rate or average across coins.

A creator wallet's pump.fun launches, from the chain only, newest first: when each launched, whether it graduated and how fast, and the counts of launches and graduations (launches the chain listener heard, since 2026-10-09). No prices and no outcomes after graduation.

Everything knowable about one launch `minutes` after it happened, and nothing knowable later: launch facts, the creator's record and wallet age, the curve at every poll up to the cutoff, metadata and paid attention if they were seen in time, and the regime at launch. Plus the outcome labels that exist so far, kept separate. {"found": false} for a coin the launch records do not have.

Rows of features at decision time plus outcome labels, for research. Set-based and point-in-time: a feature never leaks from after the cutoff -- so at minutes=5 the +10m poll and mcap_growth_2m_10m are absent by design; ask for minutes=10 or 30 to have them.

The priors a launch rule has to beat: organic graduation, and given an organic graduation, price up and liquidity alive at +1h and +24h.

The referee, on the HOLDOUT half of graduates. Price horizons (up_5m, up_1h, up_6h, up_24h) are trades: buy +2 min after an organic graduation from a funded pool, sell at the horizon, fees and slippage both sides. Reports the hit-rate test (exact binomial, deflated for every rule tried at that horizon) and expected_return, whose lower bound tightens with every referee trial; ev_passed is what live trading requires. Recorded whether it passes or not. Search with meme_rule_explore first -- it is free.

Score many rules at once on the DISCOVERY half of graduates: n selected, hit rate, and expected net return after fees (mean, median, bootstrap lower bound), ranked best first. Records nothing and costs no trial -- the referee (meme_rule_test) scores on the other half, which this never shows. since_hours is capped at seven days so the 60 s research bound can finish while live trading uses the same database.

Paper tickets on the last 24 hours of graduates, then 48, then 60, in one read. Each window says whether mean net return after costs is above zero (`grew`). `use` is true only when every window grew on at least 3 tickets. Not a referee trial; records nothing. Call this once instead of three explores -- a chat that holds the live database for 60 s is killed.

For each active live run: its own coins (its entry rule, on every finished 12-hour path), replayed minute by minute under its current exits and under each of the hold-replay grid's settings. Per setting: the paired gain per ticket in % points, its 90% bootstrap interval, each half of the coins, winners hurt and losers helped, and the big coins' difference; per run, reality_p, White's reality check on taking the best of the grid. verdict "propose" needs the interval above zero, both halves gaining and reality_p <= 0.10 on at least 30 coins. route "desk": inside the desk's fences (dex_manage exits can set it); "owner": it loosens what the owner deployed, so it goes to him with these numbers. The holdout's coins are never used. Records nothing, applies nothing.

Served from the hold replay's last pass (every three hours; from_hold_replay_pass, pass_age_s). A run new since that pass, or whose exits, rule, desk filters or owner's exits changed since it, is verdict "pending" until the next pass. This call never streams paths: that takes minutes and live trading uses the same database. fresh=true is ignored.

This tenant's rule trials, newest first: what was tried, what it scored, how deflated it was. The N that meme_rule_test deflates by.

One funding cluster: wallets funded from the same source, their launches, graduations (instant vs organic) and rug proxy. A serial launcher who rotates wallets is one row here.

Boosted mints seen, how many are launches we track, how many graduated, and whether the boost came before or after graduation.

What the launch says about itself -- socials, website, image hash -- and how many earlier launches it collides with by name, symbol or image. {"found": false} for a coin the metadata sensor has nothing on.

Start acting on a launch rule as launches happen. PAPER by default: every two minutes the runner opens simulated positions in launches the rule selects at its decision minute, marks them at the newest curve/AMM price, and exits mechanically, booking pump.fun and PumpPortal fees and slippage.

mode='live' creates the same run HALTED. It trades real SOL through the PumpPortal Lightning wallet only after meme_arm sets caps, and only while no kill switch is set. Fills are then what the chain confirms.

Entry guards for a LIVE graduation run (a price-horizon rule), set here in params and by nobody else; unset, a run buys as it always has: entry_max_signal_age_s: seconds. A coin whose +2 min mark is older than this at the buy is skipped (the tick fires once a minute, so a mark is 6-52 s old by then). paper_entry_slippage_pct (PAPER graduation runs): per cent the entry pays over the +2 min mark, which is where paper otherwise fills. The stake buys that much less and the stops and P&L are measured from the worse entry; marks still follow the tape. Unset = fills at the mark. entry_backfilled_launch: true. A live run never buys a coin not heard on the stream. With this it may buy one whose graduation WAS heard and whose launch record alone was filled in from pump.fun afterwards (about half the refused coins); never one whose graduation was not heard. Such a coin has no initial_sol, mayhem flag or curve readings, and on the day this was added those coins did worse than the rest. entry_price_check: {"min_x": 0.6, "max_x": 1.15}. The buy's own Jupiter quote, as a multiple of the mark's price, must be inside the band, and the rule's entry_fdv_usd and entry_fdv_sol clauses must still hold at that price; no quote or no SOL/USD price means no buy. SOL/USD is pump.fun's figure; with MEME_SOLUSD_FALLBACK=on (an operator's setting) the chain's when pump.fun has none. Jupiter backend only.

Let a mode='live' meme run spend real SOL. Real money moves after this.

The run's rule must have passed the referee on a price horizon; if it has not, you can still arm it by saying so in the second phrase, and that acceptance is recorded on the run. Caps are enforced on every buy; sells are never blocked by caps. meme_kill stops everything at once.

Change how much real SOL each buy of a meme run spends, or how many coins a live run may hold at once with real SOL. This moves real money: the next live buy is sized, and counted against the run's places, by what this sets.

A fixed size_sol, or a share of the wallet (wallet_pct) that follows it from trade to trade -- and, for a run sized from the wallet, a size policy that sets that share from the run's own closed live trades (half-Kelly on a cautious edge, between min_pct and max_pct), or clear_size_policy to go back to the fixed share. Every ticket stays under the armed max_trade_sol (re-arm first to go higher), the run's cash and every cap of the buy. The desk's size_pct can only make a policy's ticket smaller. A member of the owner's book is sized by the book while the book is on, whatever this says. The answer shows what the policy sizes at now, and the least the wallet must hold for that ticket to clear the 0.01 SOL floor.

max_positions changes how many coins a live run may hold at once with real SOL (1-4). With more than one, each ticket is its share of the SOL free in the wallet when it is bought, so the next one is smaller while the others are held; the daily cap and the loss cap count every open position. It waits for a tick under way to finish, then applies from the next one.

Switch a meme run's every-trade alerts on or off (params.alert_every_trade): for a run left to trade on its own.

End ONE send admission past its time that a kill cannot count as over by itself -- its sender on another host, or a process that cannot be told gone -- after making sure that sender cannot send. The operator's, by hand: the exact phrase, evidence in words, and the owner's secret once the server has one. Recorded in the desk's audit rows and told on Telegram. Never an agent's.

Say what became of ONE stuck live buy -- one given up on as 'unknown' whose expiry the chain cannot prove, or one 'submitted' with no signature by a backend that may have sent it -- after looking at the wallet and the chain. Until then it holds its run's caps and its coin, and a run with one place cannot buy. The operator's, by hand: the exact phrase, evidence in words, and the owner's secret once the server has one. Every attempt is recorded in the desk's audit rows, every act told on Telegram. Never an agent's.

Replace ONE live meme run's exits with a complete, tested exit set, in one step. `exits` is the WHOLE new set, not a patch: every key the run should hold, and a key it has that the set leaves out is removed. Every value must be inside the automatic exit step's hard bounds (AUTO_EXIT_BOUNDS) and the set must pass the runner's exit rules; unknown keys are refused, and every problem is named at once. Written in ONE statement, only while the run has no open position and no buy in flight or of unknown outcome, and only if its exits are still what was read -- otherwise nothing is written and the answer is busy: try again. The new set becomes the run's own (owner_exits): the desk tightens from it and the automatic exit step compares against it; the exits it replaced are kept on the run (params.desk.owner_exits_change) for an exact revert. Refused while the automatic exit step is acting on any of your live runs (a pending, canary, applied or promoted change, or a freeze). The owner's alone: it needs his secret, and no agent allow-list names this tool. Every attempt is in desk_actions (owner.exits); an applied set is sent to the owner's Telegram. Never size, caps, entries or arming.

Halt a live meme run: no new buys. Open positions stay in the wallet until meme_runs stop sells them.

kill: halt every live meme run and refuse every transaction from the wallet until unkill -- buys AND sales: exits stop too, and open positions are held as they are. When it returns nothing new can be sent. If a send already under way has not finished after 60 s it ERRORS instead (the kill is incomplete; the switch is set and the runs halted): call it again. Flatten a run deliberately with meme_runs stop (after unkill). An operator's kill also disarms the agent's box, and its switch stops the box's entries within about 2 s (at most 5 s) -- not at this return: "nothing new can be sent" is about prod's wallet. A tenant's kill never touches the agent. unkill: clear the switch; runs stay halted until armed again, and the agent stays disarmed until an operator command.

Wallet balance, kill state, live runs with their caps and today's spend and loss, open live positions, and the last 20 venue orders.

Takes no parameters.

Switch from paper to live. Real money moves after this.

Arming does not make a strategy tradeable: the eligibility chain still has to hold for every order. It only removes the blanket refusal.

Kill switch. Returns the account to paper and halts it.

Outranks everything, including an armed account with headroom left.

Refuse every LIVE order on every venue and run until trading_unkill.

Paper keeps recording. Nothing is flattened: live positions are held, and closing them is a separate decision.

Clear the global kill switch. Re-arms nothing: each account keeps its mode.

Every gated strategy, re-checked under the CURRENT cost model.

Read-only: writes no gate row, enqueues no backtest, spends no holdout. A run costed below today's taker fee is reported 'needs_rerun' with an estimated expectancy at the new fee, not re-gated on stale returns.

Takes no parameters.

Place a market order, or record exactly why it was refused.

On a paper account this always succeeds and never reaches a venue. On a live account the strategy must be frozen, must have spent its holdout, and that holdout must have been net-positive after the pinned cost model.

Hand a researched strategy to the conveyor that takes it toward live.

From here everything is deterministic and runs on a timer: gate_check on the submitted spec, strategy_freeze with the best run's parameters, one confirming backtest if freezing changed the hash, the one-shot holdout, then a PAPER run that must incubate before a human can promote it. You do not need freeze or holdout rights to use it -- the pipeline applies the same rules those tools do, and a rejection is final for that spec. Submit only specs with a recorded backtest on this split.

Watch a meme coin bought by hand in the Coinbase app's DEX trading: priced every minute, and a Telegram alert the moment an exit rule fires -- sell half at 2x, trailing 30% once up 30%, cut at -50%, time stop 6 h, rug. Each open position lists every rule's state (done / fired / armed / waiting) and the one nearest to firing. Places no order: Coinbase DEX trades are the owner's taps, recorded here with sold_half / sold_all.

Recent graduates worth $150k+ in a funded pool two minutes after graduating, newest first, each with its bucket's track record and any scorecard block. The operator gets the ideas as sent to his Telegram.

How graduates like the scout's ideas actually did (reached 2x, ended under entry, rugged within 6 h) overall and by graduation kind, coin size and pool size -- and how Kiro's BACK/VETO calls scored. Use it to judge an idea.

For the Telegram relay: undelivered DEX alerts, and marking them sent. The customer actions let the relay deliver every linked account's alerts with the bot token staying on the relay box.

A coin sheet's chart and its base rates. Candles come from the coin's deepest pool (GeckoTerminal, cached a minute; "stale": true when the free tier is busy). Base rates are the scout's own graduation history.

Coins you are eyeing but do not hold, with price, 24 h change, FDV and pool size (one batched DexScreener read). Up to 100.

The exit coach's rules for coins you add FROM NOW ON. Each position keeps the rules it was added with, so changing these never rewrites a live one.

Your day on the DEX side: alerts by kind, exits, wins, how much of each peak was kept, P&L where amounts were given, and what is still open.

Your alerts, newest first: exit-coach calls, rug warnings, graduates, the daily summary. Each has kind, text, created_at, read_at and whether it was delivered to your Telegram.

Get your own alerts on Telegram: ask for a link code, send it to the bot, and the exit coach reaches your phone.

Run the owner's live Coinbase lab within fences only the owner can move. retire SELLS a live position. Switching the lab on, the $ target and the fences are not available here. Every action is sent to the owner's Telegram.

Set the lab's high-water mark and today's starting equity to the lab's equity now. It LOOSENS the breakers: the fall measured so far is forgotten. For a profit sweep that settled after the breakers had stopped waiting for it, whose SOL the marks may still count (the sweep's alert says when). Refused while a sweep is in flight. The owner's alone: no agent allow-list names this tool.

Run the owner's live DEX runs within fences only the owner can move. close SELLS a position. Arming, the caps, the base rule and funding are not available here. With several runs at work every action names its run (run_id): none is ever guessed. For a run in the owner's book, size is a ceiling under the book's ticket. Every action is sent to the owner's Telegram.

The live lab: what trades with real money now (allocation, live return, round trips), the pool of scored ideas waiting for a slot, what was retired and why, and the last cycles' equity and actions. The lab generates its own ideas from a template grammar, scores them net of the measured fee on a train window and the latest weeks, trades the best, sizes them by live results and retires losers -- every 30 minutes, without a gate.

Takes no parameters.

Score one idea exactly as the lab scores its own (net of the measured fee, volatility stop, train window + the latest weeks). If it is positive in both with trades in both, it joins the pool and competes for a live slot on the same terms. Places no order itself.

Where every candidate stands, or one candidate's full history.

Stages: submitted -> confirming -> frozen -> incubating -> live_ready -> live, or rejected / retired with the reason. The policy block states the rules in force (paper days, capital, whether the holdout spends itself).

Run the pipeline's next step for one candidate immediately, rather than waiting for the ten-minute tick. Same rules; nothing is skipped.

Start real-money trading for a candidate that has earned it.

Refused unless the candidate is live_ready (holdout net-positive AND paper incubation passed), the account is already armed with trading_arm, and the capital is within the policy ceiling. The paper run keeps running beside it as the shadow its live fills are compared against.

Take a candidate out of the pipeline: stops and flattens its live and paper runs. Final for that spec.

Start a run that trades REAL money on the armed account.

The account must already be armed (trading_arm). A strategy that has not earned eligibility can still go live if you accept it as unproven, in those exact words; on bars faster than 1h a second phrase accepts the fee drag. Both acceptances are stored with the run. The kill switch, per-order and daily caps and the drawdown halt all still apply. For a strategy that did earn it, prefer pipeline_promote.

Refused while Coinbase trading is retired: nothing ticks runs any more.

Start the loop: every few minutes the runner evaluates the frozen spec on closed bars, rebalances to its target through order_submit's gate, and marks equity at the live bid.

PAPER unless the account is armed: fills are simulated at the live bid/ask after the pinned cost model, and no venue sees an order. Live runs carry the same books, are reconciled against the venue every tick, and halt on drift. The drawdown limit needs nobody awake.

Refused while Coinbase trading is retired: nothing ticks runs any more.

The operator's view of a run. 'status' is the books and the last marks and orders; 'report' the equity curve since deploy; 'tick' runs one loop iteration now (no timer ticks runs any more); 'stop' flattens and ends it.

Your plan, this month's usage, and what remains.

The metered unit is the trial, not the API call — every trial permanently raises the bar your own results must clear, so it is the scarce thing worth pricing. A smaller sweep buys a lower deflated-Sharpe hurdle as well as a smaller bill; the constraint runs with the statistics rather than against them.

Takes no parameters.

Your credits: the balance, each live bucket (plan or top-up) and when it expires, what your plan grants a month, what you used this month, your recent grants and spends, and the price of each kind of work.

The credits one piece of work costs, your balance and whether it covers it. A chat turn is priced by its tokens.

Spend credits from YOUR OWN balance for work done outside this server (the QuantBase app's chat turns, priced by tokens). Idempotent on idem_key. Only ever charges the caller.

Start a checkout for a credit top-up (one payment; the credits last 90 days).

Start a hosted checkout for a paid plan, bound to YOUR account: the checkout carries a signed tenant hint and your verified email, locked. Only ever for the caller. Returns the url to send the browser to.

The plans on sale: price a month, credits a month, whether live trading is included, plus the credit top-up and what each kind of work costs.

Takes no parameters.

Your the agent bot's settings: name, rule, exits, limits, status, default mode and paper run.

Takes no parameters.

Apply changes the person CONFIRMED. Each changed setting is logged with the reason. Who made the change is recorded by the server (always the signed-in person here): a caller cannot label its own change as the agent's.

Every confirmed change to your bot: what, before and after, why, who, when.

Your paper money (it never touches a wallet): free, reserved by paper runs, and its history. On a paid plan it is unlimited (unlimited: true): a reservation is never refused for the balance.

Set aside paper capital for a paper run (once per run). On a paid plan it is never refused for the balance: what the run needs beyond the free paper money is added first.

Give a paper run's capital back as the run's own result, worked out by the server (once per run).

Put your paper money back to the starting 10 SOL (only with no paper run holding any).

Takes no parameters.

Your conversations with the agent, newest first; filter by paper or live.

One of your conversations with its messages (after a seq, for incremental sync).

Create a conversation (no id; mode paper unless live is asked) or append messages to one. A conversation's mode is fixed when it is created.

Delete one of your conversations and its messages for good.

What each plan includes.

Takes no parameters.

The drivers of crypto price, joined against the data actually held here.

Listing what moves a market is easy and answers nothing. The question that decides whether a driver is a research direction is narrower: can this server measure it, on data it already has, over a span long enough to support the search?

So each entry reports what it would need, what can be proxied from the OHLCV that exists, and the specific way it tends to fail. Most of them are not testable here -- which is a more useful answer than five plausible directions and no way to tell them apart.

Takes no parameters.

How much more searching this data can actually support.

Every backtest you run raises the bar the survivor has to clear, because the best of N noisy attempts is large by construction. Bailey's minimum backtest length inverts that into something you can budget against:

MinBTL(N) = 2 * ln(N) / E[max Sharpe]^2 years

Solved the other way, a fixed span of history implies a MAXIMUM number of trials it can honestly support:

N_max = exp(years * E[max Sharpe]^2 / 2)

Past that point more searching cannot produce a defensible result, however good the number looks -- the data is no longer long enough to tell a real edge from the best of many coincidences. Most research tools encourage you to keep going. This one tells you when to stop, and how many attempts you have left before that happens.

`expected_max_sharpe_annual` is the Sharpe you would expect the best STRATEGY IN YOUR SEARCH to show by luck alone. Raising it flatters the budget, which is why it is stated as an input rather than inferred: the number you choose is an assumption you are making, and it should be visible.

Every strategy and split this principal has registered.

gate_check and holdout_evaluate are addressed by strategy_id and split_id, and nothing handed those ids back once the registering conversation had ended. A caller who had lost them could not name their own frozen strategy again: re-registering the same spec is rejected on the hash, which is correct and also a dead end. Row-level security scopes both selects, so this is an inventory of the caller's own work and never a directory of anyone else's.

Splits carry the dataset they were cut from because a split is only meaningful against those bars -- gate_check pairs the two, and a split_id on its own does not say what it splits.

Takes no parameters.