tradefloor
This MCP server provides a deterministic market simulator for validating, evaluating, ranking, stress-testing, explaining, and interactively trading strategies in simulated markets.
Describe the simulator, shipped presets, realism records, populations, caps, and session behavior.
Check whether a proposed run falls inside the measured realism envelope before running it.
Validate strategy specs and build/preview custom company rosters and scenarios.
Evaluate strategies on one market beside baselines, or rank them across multiple seeds with paired sign tests.
Run macro stress scenarios against an unshocked market, including fork-based comparisons.
Explain price moves by 12 factor contributions and trace moves down to random draws.
Start and poll background jobs for longer runs up to the certified 252-day horizon.
Open interactive market sessions to step with orders, inspect state, fork, rewind, and close, optionally with background trader populations.
Provides a LangGraph adapter enabling LangGraph agents to drive tradefloor simulations, step through market sessions, fork and rewind states, and analyze simulated price moves.
Provides an adapter for the OpenAI Agents SDK, allowing OpenAI agents to use tradefloor's market simulation tools, including strategy evaluation, scenario stress testing, and interactive market sessions.
Provides a PydanticAI adapter so PydanticAI agents can run simulated markets, evaluate trading strategies, rank them across seeds, and test macro stress scenarios through tradefloor's MCP tools.
tradefloor
tradefloor is a market simulator you can run a strategy against. It has a Rust core and a Python API.
Give it a seed and a list of companies. It runs a market forward: prices, a limit order book, fills, and an economy that moves each day. Your orders match against the book's depth, so your trades move the price.
Real market data can't tell you what would have happened if you had traded
differently, or what caused a move. tradefloor can, because it computed every
price. You can fork a running market, change one thing in one branch (a rate
rise, a liquidity crisis, a different agent), and measure where the two
branches came apart. engine.truth() splits each move in the gap between a
price and the model's fair value into twelve factors, and
engine.explain(ticker, day) breaks down the move in the traded price, two
records no historical dataset carries.
Documentation is at https://docs.tradefloor.dev.
Install
pip install tradefloorThere are wheels for Linux, macOS and Windows on CPython 3.11+, and no
dependencies. The same engine is a Rust crate (cargo add tradefloor).
Optional extras add the MCP server (tradefloor[mcp]), Arrow output
(tradefloor[arrow]), the Gymnasium environment (tradefloor[rl]) and one
extra per agent framework.
The API may change before 1.0. Model changes ship as new presets, so a market with no agent orders in it replays exactly on its named preset in later releases. tradefloor was called pretium until 0.5.0. Versions up to 0.4.3 still install under that name, and results recorded with them still replay.
Related MCP server: Sablier MCP Server
A first run
import tradefloor as tf
universe = tf.Universe.random(40, seed=111)
spec = tf.StrategySpec.momentum(lookback_days=1.0, top_k=5)
scores = tf.evaluate({"mine": spec}, seed=7, universe=universe, days=10)
scores["mine"].return_pct # what it made
scores["mine"].impact_bps # what its own footprint cost
scores["mine"].strategy_fingerprint # sha256, cite this
scores["mine"].errors # each step that raised or was refused
scores["mine"].sharpe # annualised, from the daily closes
scores["mine"].time_in_market # share of steps holding a positionThat result comes from one random market, so it says as much about the seed
as about the strategy. tf.rank runs many seeds and compares strategies with
a paired sign test. Add tf.baselines.reference_agents() to the entrants and
tf.versus_buy_and_hold(scores) reads each score against buy-and-hold on
the same market.
A Python agent is any object with act(obs) that returns orders: a number
of shares for a market order, tf.Limit(quantity, price) or tf.Cancel().
It sees a read-only view of the market and its own portfolio, and
obs.history holds a daily bar per name. A bar's close is the day's last
print. On pt-v21 the close then re-marks every name and the next session
opens after an overnight move, so the next day starts away from that print:
the close sits 11 bp from it at the median on a 20-name roster, and the open
25 bp from the close.
docs/AGENTS.md
covers what the view holds, how trades are charged, the framework adapters
(OpenAI Agents SDK, PydanticAI, LangGraph, FinRobot) and how scoring works.
The demo
The examples are in this repository and not in the package, so clone it first:
git clone https://github.com/simoncoombes/tradefloor
cd tradefloor
python examples/rate-shock/counterfactual.pyIt runs an agent in a controlled market, checkpoints the world and forks it, raises rates by 200 bp in one branch, and compares what the same agent does next. It prints nine checks that the two branches started identical, the step at which the agent's behavior changed, and the two branches side by side. The run takes under five seconds of CPU and needs no keys and no network. The walkthrough is Your first counterfactual experiment.
Contents
| why each price moved: twelve factors that sum to the mispricing's move, to 1e-16 |
| how each trade price came about: the shock, and the order book depth that absorbed it |
counterfactual TCA | your trading cost, from the same seed run with your orders and without them |
| many seeds, paired sign tests |
| what a reader needs to replay a run, checked by |
| fork a running experiment, change one variable, and measure where the two came apart |
scenarios | seven packaged shocks, and a file format for your own |
MCP server | twenty-two tools for a coding agent, sixteen of them read-only, with scenarios, any shipped preset, a shipped population of background traders, and market sessions you step, fork and rewind |
more | a Gymnasium environment, Arrow output, checkpoints, SEC EDGAR data, simulated rate indices, a browser build |
Drive it from an agent
pip install "tradefloor[mcp]"
claude mcp add tradefloor -- tradefloor-mcptradefloor-mcp speaks MCP over stdio, and tradefloor mcp starts the same
server. Strategies, universes and scenarios are data, so a tool argument
cannot reach code. Each result carries its own caveats. A session keeps one
market in the server between calls, so an agent can place orders a step at a
time, fork the market to try two actions, and rewind. See
the MCP page.
Scenarios
engine = tf.Engine(seed=42, universe=universe)
engine.run_days(20) # a shared history first
scenario = tf.Scenario.load("liquidity_crisis") # ships with the package
control, stress = tf.branch(engine, 2)
for day in range(80):
scenario.apply(stress, day)
... # run both branchesA scenario is a file of changes to the market and the assumptions behind them. Each change targets a field the engine reads, and the file keeps the shock apart from the knock-on effects you assume follow it:
tradefloor scenario show oil_price_spike
Exogenous shocks
----------------------------------------------------------
day 50+ commodity.oil x1.4
Assumed transmission
----------------------------------------------------------
day 55..74 ramp macro.inflation +1.50pp
day 55+ macro.corporate_yield +0.50ppat in a scenario counts days from the first day it is applied, so on a
branch it counts from the branch. Most packaged files first fire on day 50.
To fire one on the first day after a fork, use scenario.starting_at(0), or
world.apply(scenario, at=0) on a World. The gaps between its events stay
the same, and the run's record keeps the packaged file's fingerprint and the
days each event fired.
tradefloor does not predict what a war, an election, an oil shock or a
recession will do to markets. You state the assumptions and it measures how an
agent behaves under them. tradefloor scenario list names the seven packaged
scenarios, and tradefloor scenario targets lists every field a scenario can
change.
Reproducibility
The same seed gives the same market on every platform. tradefloor ships its
own exp, log, pow, sin and cos, so the system's math library cannot
change a result, and each release runs a fixed simulation on five platforms
and stops if any result differs.
A shipped preset never changes, so a market with no agent orders in it replays
exactly on its named preset in every later release. Each release checks that
with a digest per preset. A run with agent orders in it replays exactly on the
same release. Across releases the promise is narrower. 0.8.5 changed how an
agent's fills reach the market, on every preset, so a traded run recorded
before 0.8.5 matches up to its first trade and differs after it.
The default preset is pt-v22, and pt-v21 or any other shipped one can be
named:
eng = tf.Engine(seed=42, universe=u, model="pt-v10")pt-v22 lists index, rate and oil futures and options on every name. It is
the default from this release, so a run that left model out on an earlier
release gives a different market here.
To let a reader rerun a result, publish its RunManifest. It records the
version, preset, seed, universe, macro state and scenario, and reproduce()
stops on a mismatch. A manifest checks the market and carries no score. Its
result block holds the market's digest, the number of days and
draws_consumed. tf.evaluate and tf.rank write no manifest, so a
published score has to be rerun to be checked.
docs/REPRODUCIBILITY.md
has the full contract, including what a saved engine state promises when it
is restored, and
docs/SUPPORT.md
says which release to pin for a long study.
Realism
tradefloor checks its market against real ones with three named sets of statistics, listed in docs/STATISTICS.md. On pt-v22, the default, 19 of the 19 statistics of the one-year table (volatility, fat tails, how much stocks move together, how far the VIX jumps after a fall) are inside the range real markets show over a year. pt-v22's long-run criteria are 190 rows over 21 years, covering crash depth, how long fear lasts, bear markets per decade, the 2008 and 2020 replays, the rate indices, the cost of size in the book, strategies built to find an edge, and the futures, options and margin (docs/MODEL.md). pt-v22 meets all 190, read on 270 histories. Two more rows are shown for comparison and not counted. On pt-v21 (the default from 0.10.0 to 0.10.2), all 19 one-year statistics are inside their ranges, on the ruled bands. The index's return and the share of days it falls 3% or more are read over 360 seeds, as the long-run criteria read them: the index falls 3% or more on 0.98% of days, against a range of 0.64 to 2.34. All 15 statistics of the two-year panel are inside their two-year ranges. pt-v21 meets all 40 of the long-run rows it was graded on, read on 270 histories.
Read those claims narrowly:
The one-year count is a verdict on figures pooled over 30 seeds (360 for the index's return and 3% falls). One seed's year often misses some of its 14 shape statistics. On seeds 101 to 116, all 14 were in range on 8 of the 16, and one seed had 11 of 14. If you run one market per condition, read
tf.envelope.intervals()for each statistic's spread across seeds.A shape statistic's range is the median of 35 real one-year windows plus or minus 2.1 trimmed standard deviations, so passing one is weak evidence. Volatility clustering is one case.
abs_return_acf5reads 0.028, below every real 2015 to 2025 window (the lowest is 0.034), and it passes because its range reaches lower than those windows do.The VIX is stickier than real: its day-to-day persistence reads 0.956 against the tape's 0.930, and the sign test that grades it refuses it.
The one-year table helped choose many of the coefficients pt-v22 keeps, so the held-out checks are the fresh seeds and the fresh set of companies the panel is repeated on.
One year is the certified horizon. Two years is graded on the two-year panel, and longer runs only by the long-run criteria.
A driven scenario moves prices at about half to four-fifths of the real size, in the right direction. Use a scenario to detect a response, and do not read its size as a forecast.
Volatility memory reads 0.095 at lag 1 against a real 0.107 and fades much faster after it: at lag 20 it is under a twentieth of real. Nothing below the 65-minute step is calibrated.
An order sliced over a day costs a median 0.13 of a daily standard deviation for 10% of a day's volume in 36 slices, at the low end of the 0.15 to 0.3 published studies find.
By default no other trader reacts to you, so no liquidity spiral or predatory trading can arise. Populated mode adds background traders that trade your signals and front-run predictable flow, but they charge a predictable programme about 2.4% more, far below what real markets show.
tf.envelope.check(horizon_days=...) refuses a question that falls outside
a measured limit.
docs/REALISM.md
has every number behind these claims and the full table of limits.
Before you publish a result
An agent scored on naming the factor behind each day's move gets an
explanation_accuracy. On pt-v21 a constant answer scores 0.70 to 0.95, so quoteexplanation_edge, the accuracy minus that baseline, and never the accuracy alone.Agents in one
tf.evaluateortf.rankcall run one after another in one Python process, on one seed. An earlier agent can leave the price path in a class variable for a later one. An agent written to cheat can read the seed from the harness's frames throughsys._getframeand run a copy of the market ahead. Nothing flags either. The read-only market view guards only against accidents, so run each agent you did not write in its own process, through the MCP server.Every
evaluateandrankrun starts at day 0, so a rule that needs 20 days of prices sits out the first 20 while buy-and-hold is invested. Passhistory_days=20to run the market 20 days first with nobody trading.In a
Worldwith several agents, orders placed at the same step execute in label order, alphabetical, for the whole run. Rotate the labels across runs when you compare different agents in one market.There are no commissions, no borrow fee on a short and no stop orders. A stop you check at each step fills a median 26.5 bp past its level at six steps a day. Uninvested cash earns nothing unless you pass
cash_interest=True, and a negative cash balance pays the policy rate, which is below a broker's margin rate.
docs/AGENTS.md has the measurements behind each of these.
Examples
The twelve numbered examples/ are in reading order, and the test suite runs them:
Start here: one company, one year, two crises, one chart | |
Universe, engine, order book, determinism | |
Specs, baselines, ranking across seeds | |
The twelve factors that sum to the mispricing's move | |
The realism panel and the limits | |
The Gymnasium environment, and what size costs | |
TCA and the counterfactual run | |
A whole study in one file. It takes about forty seconds of CPU and needs | |
An LLM agent trading the market through the harness | |
A real 2020-21 macro path, and which fields transmit. Pinned to | |
Fork a market, raise the rate in one branch, and compare the futures | |
A scenario file applied to one branch of a fork, and what it cost |
The rate-shock/
study is the demo above, and
integrations/
runs the same kind of experiment through each agent framework, offline and
without an API key.
Documentation
https://docs.tradefloor.dev covers install, the API, the guides and how the model is measured. These pages in this repository have the detail behind the sections above:
docs/MODEL.md: the model as equations, with every coefficient's value on the default preset and where it came from
docs/STATISTICS.md: the named sets of realism statistics
docs/REALISM.md: the realism results and every measured limit
docs/REPRODUCIBILITY.md: what replays exactly, across platforms, releases and restored state
docs/AGENTS.md: writing, scoring and comparing agents
docs/SUPPORT.md: which release lines get fixes, and for how long
docs/EMBEDDING.md: driving the Rust engine from a game or another host, and how much flow of its own the model takes
Contributing and support
CONTRIBUTING.md explains how to build and test the project. Its main rule is that any change to the simulated trajectory is a breaking change, however small, so a model change ships as a new preset. RELEASING.md is the release checklist.
Report a vulnerability through GitHub's security advisory form, not a public issue. SECURITY.md says what is in scope. Bugs and questions go to GitHub issues.
0.8.5 and the 0.8 patches after it are the long-term support line, with bug and security fixes for 24 months. docs/SUPPORT.md says what a support line promises and which release to pin for a long study.
Citing tradefloor
Cite the version you ran and name the preset. The same version can run several presets, and results depend on the preset.
@software{tradefloor,
author = {Coombes, Simon},
title = {tradefloor: a deterministic market simulator with a limit order book},
version = {0.11.0},
year = {2026},
url = {https://github.com/simoncoombes/tradefloor},
note = {Model preset pt-v22}
}CITATION.cff carries the same details, and GitHub's "Cite this repository" button reads it.
In the text, say which model you used, for example: "tradefloor 0.11.0, preset pt-v22, specified in its docs/MODEL.md". docs/REPRODUCIBILITY.md says how to publish a result so a reader can rerun it, and how to show a score was not tuned to its seeds.
License
tradefloor is licensed under MIT OR Apache-2.0, at your option. See
LICENSE-MIT
and
LICENSE-APACHE.
GitHub's sidebar reads Apache-2.0 because its license detection picks one
file and stops. The grant that applies is the dual one, stated in
pyproject.toml, rust/Cargo.toml and this section.
Available Tools
19 toolsbuild_scenarioBuild and preview a custom scenarioARead-onlyIdempotent
Author a custom scenario and see what it resolves to before running it. Give a macro PATH as hold, ramp and step instructions in steps, or explicit INTERVENTIONS as shocks and assumed transmission. Returns the resolved document, its fingerprint and any warnings; pass that document to run_stress_scenario as scenario. Days count from 0, so an event at day 50 needs a run of at least 51 days. Runs no market.
Inputs: days, label, steps, shocks, +1 more. Returns: object
build_universeBuild and preview a rosterARead-onlyIdempotent
Build a roster of companies and preview it, either generated from a size and seed (optionally concentrated on chosen sectors) or from explicit instruments you supply. Use it when the default random roster will not do, for example to test one sector or your own companies. Returns a universe document that every run tool takes as universe, with the roster's fingerprint and any envelope warning. Runs no market.
Inputs: seed, size, limit, sectors, +1 more. Returns: object
check_envelopeCheck a question against the realism envelopeARead-onlyIdempotent
Check whether a question falls inside the range the simulator's realism was measured for, BEFORE running it. Use it whenever a conclusion leans on a horizon longer than a year, on particular statistics, on a sector-concentrated roster, on the size of a scenario's effect or on a preset other than the default. Returns ok or a refusal that names the measurement behind it, and for a named preset that preset's measured record. Runs no market, so it answers at once.
Inputs: horizon_days (required), preset, statistics, macro_regime, +2 more. Returns: object
check_jobCheck a background jobARead-onlyIdempotent
Check a background job started by start_job. Returns its status and, once it has finished, the full result in the same form the direct tool returns. Omit job_id to list every job this server still holds. Changes nothing, so it is safe to poll.
Inputs: job_id. Returns: object
close_sessionClose a market sessionADestructiveIdempotent
Close an open session and free its memory, returning each agent's final portfolio and every order sent on the session's line, which is what re-runs it from open_session. The session and its checkpoints are gone afterwards. Runs no market.
Inputs: session_id (required). Returns: object
describe_simulatorDescribe the simulatorARead-onlyIdempotent
Describe what this simulator is, what its realism checks certify, what it cannot do, the caps on every tool and how long a run takes. It also lists every shipped preset with its measured record, says which one the certification covers, lists the shipped populations of background traders with what they were measured to do, and describes market sessions. Call it first, before any other tool. It takes no arguments, runs no market and returns the same text on every call.
Inputs: no named parameters. Returns: object
evaluate_strategiesEvaluate strategies on one marketARead-onlyIdempotent
Run strategies on one simulated market, beside the baseline agents on the same market, and score each one: return, P&L, the cost of its own trading in basis points, turnover and errors. Use it first, but it runs one seed, so use rank_strategies before believing an ordering. A strategy is data, for example {"signal": {"kind": "momentum", "lookback_days": 1.0}, "portfolio": {"top_k": 5, "gross": 1.0}}, and validate_strategy checks one without running it. days 1 to 60 here (a few seconds), up to 252 through start_job; roster 2 to 120 names. preset runs another shipped model preset, outside the certification, and population adds background traders that react to each strategy. Deterministic: the same arguments give the same scores.
Inputs: strategies (required), cash, days, seed, +9 more. Returns: object
explainTrace a move to its random drawsARead-onlyIdempotent
Trace one name's price move on one day down to the random draws that caused it, as a tree: the day's log move at the top, then each factor, then the draw addresses beneath them. Every node can be replayed, and every number is measured by running the day again. Use explain_price_move to see which factors moved prices across the roster; use this for one name when you need to know which draws moved those factors. depth sets how much of the tree the render text shows. Builds and runs its own market for up to 60 days, under preset if one is named; read-only and deterministic.
Inputs: day, seed, depth, preset, +5 more. Returns: object
explain_price_moveExplain a price move by factorARead-onlyIdempotent
Break one day's move for each name into the 12 factor contributions that sum to the day's change in the mispricing, the log gap between the model price and fair value. Use it to ask which factors moved prices; use explain to trace one name's move down to the random draws behind it. They are the simulator's own bookkeeping, and they are not the whole price move. On the default preset most of the day's news and noise moves fair value, fair_value_shift takes that part out of the mispricing, and the fair-value move itself is not split up. Without a ticker it returns the top_n largest moves. Builds and runs its own market for up to 60 days, under preset if one is named; read-only.
Inputs: day, seed, top_n, preset, +5 more. Returns: object
list_scenariosList scenarios and intervention targetsARead-onlyIdempotent
List the shipped stress scenarios, the scenario constructors and every intervention target, with what each target was measured to reach. Read it before build_scenario or run_stress_scenario: each shipped scenario's first_event_day sets the shortest useful run, and four targets have effects too small to see over a hundred days. Takes no arguments and runs no market.
Inputs: no named parameters. Returns: object
open_sessionOpen a market sessionA
Open a simulated market that this server keeps between calls, and get a session id back. Use a session when you want to decide each step yourself and see what happened before the next: send orders with session_step, read with session_state, try two actions from one state with session_fork, and go back with session_rewind. To score a strategy you can write as a spec, use evaluate_strategies or rank_strategies instead. agents names the traders: null for one you drive with orders, or a strategy spec for one that trades itself each step. preset and population choose the market as they do for evaluate_strategies. Opening runs no market. At most 8 sessions are open at once, in this server's memory only, and one idle for 30 minutes is closed.
Inputs: cash, seed, agents, preset, +7 more. Returns: object
rank_strategiesRank strategies across many seedsARead-onlyIdempotent
Score strategies across MANY seeds, beside the baseline agents, and rank them with a paired sign test on each pair. Use it after evaluate_strategies, because one seed's ordering is often luck. Costs about one evaluate_strategies call per seed: 2 to 12 seeds (default six), days 1 to 60 here, up to 252 through start_job. Returns each entrant's record across the seeds (median P&L, seeds ahead of buy-and-hold) and each pair's sign test. Takes preset as evaluate_strategies does. Runs isolated only and refuses population, because the paired test needs every strategy on the same market. Deterministic.
Inputs: strategies (required), days, seeds, preset, +7 more. Returns: object
run_stress_scenarioRun strategies through a stress scenarioARead-onlyIdempotent
Run strategies through a macro stress scenario, always beside the same market unshocked, and compare each strategy across the two. scenario is a shipped document by name (list_scenarios gives each one's first_event_day, and the run must be longer than that), a constructor by name (vix_shock, rate_ramp, timed with peak_day), or a document from build_scenario. A scenario whose events all fall after the run is refused. Pass fork_day to run both markets together first and start the scenario on that day, as a fork of one shared history. Use the result to detect a response, not to forecast its size. days 1 to 60 here, up to 252 through start_job. Takes preset and population as evaluate_strategies does, the same in both markets. Deterministic.
Inputs: scenario (required), days, seed, preset, +8 more. Returns: object
session_forkFork a market sessionA
Copy an open session, at its present state, into a new session with its own id, so you can try two different actions from the same market and compare them. The copy continues exactly as the original would: the same steps and orders give the same prices in both. The original is unchanged. Counts against the 8-session cap; runs no market.
Inputs: session_id (required). Returns: object
session_rewindRewind a market sessionADestructiveIdempotent
Put an open session back to a checkpoint it kept, by step, and drop every checkpoint after it. Checkpoints are kept at the open and at the end of every session_step call; session_state lists them, and a session keeps at most 64. To keep the later state as well, session_fork first. Returns the session as session_state does. Runs no market.
Inputs: step (required), session_id (required). Returns: object
session_stateRead a market sessionARead-onlyIdempotent
Read an open session without changing it: the clock, every price, the published macro figures, today's news by name, each agent's portfolio and open orders, and the checkpoints session_rewind can return to. Name tickers to add each one's open, high, low, volume and best bid and ask. It shows what a trader could see and nothing of the simulator's own state. Omit session_id to list the open sessions. Runs no market.
Inputs: tickers, session_id. Returns: object
session_stepAdvance a market sessionA
Advance an open session by a number of steps or days, optionally sending orders for one of its agents at the first step, and get back the fills, each agent's portfolio, the prices and what changed. This is the one session tool that trades. An order is a signed share count (positive buys), {"quantity": q, "limit_price": p} for a limit order, or "cancel"; a malformed order is refused before anything runs, and one the market refuses (the leverage cap, a book that cannot fill) is listed and the rest trade. At most 360 steps a call and 504 days a session; a step costs about a sixth of a day of evaluate_strategies for one entrant. Keeps a checkpoint at the step it ends on. Deterministic: the same calls from the same open give the same result.
Inputs: session_id (required), days, agent, steps, +1 more. Returns: object
start_jobStart a background simulationA
Start a long run of evaluate_strategies, rank_strategies or run_stress_scenario in the background and get a job id back immediately. This is the ONLY way to run to the certified 252-day horizon; a direct call is capped at 60 days so it can answer inside a conversation. The arguments are checked before the job starts, and the response estimates its run time. At most 2 jobs run at once and the last 32 are kept, in this server's memory only. A preset or population in the arguments is checked before the job starts. Poll with check_job.
Inputs: tool (required), arguments. Returns: object
validate_strategyValidate a strategy specARead-onlyIdempotent
Parse and fingerprint one strategy spec WITHOUT running it. Use it to iterate on a spec cheaply before evaluate_strategies or rank_strategies: a grammar error comes back naming the field that was wrong, and a valid spec comes back normalised with its fingerprint. A spec looks like {"signal": {"kind": "momentum", "lookback_days": 1.0}, "portfolio": {"top_k": 5, "gross": 1.0}}. Runs no market.
Inputs: spec (required). Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 19 tools
Despite many 'run' tools, the boundaries are explicitly drawn: evaluate_strategies (one seed) vs rank_strategies (many seeds, sign test) vs run_stress_scenario (shocked vs unshocked) vs start_job (only way to 252 days). explain vs explain_price_move are contrasted (roster-wide factors vs one name's draws), and the session family (step/state/fork/rewind/close) each has a distinct verb of effect. An agent can reliably pick the right tool.
Mostly a clean snake_case verb_noun pattern (validate_strategy, evaluate_strategies, run_stress_scenario, build_universe, list_scenarios, check_job). The session tools use a noun_verb namespace (session_step, session_fork, session_rewind) while their brackets are verb_noun (open_session, close_session), and bare 'explain' breaks the pattern, but the deviations are minor and readable.
19 tools is slightly heavy but each earns its place: 6 cover a full interactive session lifecycle, 3 cover strategy scoring at different fidelities, plus jobs, scenario/universe authoring, explanation, and read-only orientation tools. Nothing looks redundant enough to drop, though the surface is dense.
Coverage is strong: cheap validation, single- and multi-seed evaluation, stressed runs, causal explanation, background jobs for long horizons, envelope/realism checks, and full session control with forking/rewinding. Only marginal gaps (e.g. no consolidated cross-preset comparison or result export beyond jobs/session_state), which agents can work around.
Maintenance
Related MCP Connectors
Trading MCP server for AI agents, with live market data, account reads and controlled execution.
Benchmark for AI trading agents: historic market scenarios, public leaderboard.
Paper trading for AI agents: 45 stock markets, virtual money, real broker fees, live or replayed.
Research-only MCP server: your AI as a quant research desk. 90 tools, no trades, no brokers.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceMCP server that provides AI agents with financial tools including real-time quotes, backtesting, technical analysis, and multi-exchange data via a simple CLI interface.2MIT

Sablier MCP Serverofficial
AlicenseAqualityDmaintenanceAn MCP server that lets AI assistants analyze portfolios, stress-test scenarios, generate synthetic market paths, and scan SEC filings — in under 2 minutes.833MIT- AlicenseAqualityCmaintenanceAn MCP server exposing a registry of paper-backed quantitative trading methods plus a deterministic, no-LLM decision helper for reproducible trading research.1331 PyPIMIT
- AlicenseNot gradedqualityCmaintenanceAn MCP server that lets you talk to your AI trading assistant in plain English to research stocks, generate trade recommendations, manage a portfolio, and execute trades through natural language.MIT