# Stochastly Desktop (pypi · stochastly-mcp)

Local MCP access to Stochastly desktop nodes, diagnostics and research tools.

- Trust score: 82/100 (high trust)
- Change this week: +16
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- pypi · `stochastly-mcp`: 82/100 (this document), [markdown](https://verifymcp.io/servers/com-stochastly-desktop/stochastly-mcp.md), [page](https://verifymcp.io/servers/com-stochastly-desktop/stochastly-mcp)

## Channel facts

- Registry: `pypi`
- Package: `stochastly-mcp`
- Version: `0.2.2`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs setuptools.build_meta at install time, a recognised build step with no custom scripting around it.
  - 0 of 28 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 20 days ago).
  - Security-disclosure policy not yet verified: we couldn't inspect the source repository.
- **Schema Quality & AI Usability**: 63/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 6555 tokens (~226/item across 29 items; 29 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 100/100
  - No destabilizing schema changes in the last 30 days.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 29 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 29 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the Stochastly Desktop MCP server?

Stochastly Desktop runs locally as a PyPI package, launched with uvx stochastly-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add com-stochastly-desktop -- uvx stochastly-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "com-stochastly-desktop": {
      "command": "uvx",
      "args": [
        "stochastly-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-stochastly-desktop": {
      "command": "uvx",
      "args": [
        "stochastly-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add com-stochastly-desktop -- uvx stochastly-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-stochastly-desktop": {
      "type": "local",
      "command": [
        "uvx",
        "stochastly-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-stochastly-desktop --command uvx --arg stochastly-mcp
```

### Hermes

```yaml
mcp_servers:
  com-stochastly-desktop:
    command: "uvx"
    args: ["stochastly-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "com-stochastly-desktop": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "stochastly-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-stochastly-desktop -t stdio -c uvx -a stochastly-mcp
```

### Other

```json
{
  "mcpServers": {
    "com-stochastly-desktop": {
      "command": "uvx",
      "args": [
        "stochastly-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-05 (score 82, +15)

- [security improvement] Malware scan: unverified → pass
- [functional regression] Security disclosure: fail → unverified

### 2026-11-04 (score 67, −15)

- [security regression] Malware scan: pass → unverified

### 2026-11-03 (score 82, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-11-02 (score 67, −15)

- [security regression] Malware scan: pass → unverified
- [security] Stability: 0.97 → pass

### 2026-11-01 (score 82, +16)

- [security improvement] Malware scan: unverified → pass

### 2026-10-31 (score 66, −15)

- [security regression] Malware scan: pass → unverified

### 2026-10-30 (score 81, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-10-29 (score 66, +1)

No change was recorded against any check on this day. Stability & Change Management went from 83 to 87. That category is still filling its 30-day observation window: 25 days of observed history at the previous scan, 26 at this one. The score rises as the window fills, whether or not the server changes.

## MCP tools (29)

### `adversarial_check` (~352 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Run six controls that try to refute a finished run (drift against its own block-bootstrap
null, an edge-free twin of the prop-firm cycle, Romano-Wolf multiplicity, concentration on the
best days, frictions, stability across sub-periods) plus a positive control that checks a
known edge would be detected on the same data.

Call it after any promising result. `synthesis` is SURVIVES, REFUTED, UNDERPOWERED (effect
smaller than the sample can resolve; `observations_needed` says how many bars it would take)
or BLIND (the positive control failed, so the sample, not the strategy, must change). Each
passed control reports its `floor`, the smallest effect it could have rejected. Deterministic
arithmetic, no language model; measured error rates in the test suite: 0.017 false
positives, 0.000 false negatives. Needs the run's full PnL series with at least 8 points; an
unknown run is a named error. Needs Stochastly open with an Atelier or Portfolio licence.

Input parameters:

- `n_boot` (integer): Number of bootstrap resamples.
- `n_sims` (integer): Number of simulations for the randomised controls.
- `run_id` (string, required): Id of a finished run, from backtest_graph or backtest_status.
- `seed` (integer): Random seed; the same seed gives the same answer.

### `analyze_dependence` (~278 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Measure the dependence between two equity curves you supply, by fitting one copula or the
mutual information to their paired increments (only timestamps present in both curves count).

Use it to ask whether two strategies or markets move together before combining them; to
actually build and judge a combined book from finished runs, use portfolio_combine instead.
Descriptive only: it reports the fit, it does not run a hypothesis test or take a decision.
Malformed curves are refused with a named error (wrong count, missing unit, unordered dates,
non-finite values). Needs Stochastly open with an Atelier or Portfolio licence.

Input parameters:

- `instruments` (array, required): Exactly two curves. Each is an object with `equity` (list of finite numbers, at least 2), an optional `symbol`, `timestamps` or `dates` (ISO dates, same length, unique, increasing) and `pnl_unit` set…
- `kind` (string, required): Dependence model: a gaussian, student, clayton or gumbel copula fit, or mutual_information on the ranks.

### `app_info` (~173 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Report the installed Stochastly app: version, build_edition, platform, python, cpu_count,
hw_factor, license_status (key masked), build (git commit, dirty flag, engine fingerprint),
engine_integrity (whether the running engine matches that fingerprint) and `_engine`
(`sidecar` when it talks to the open app, `in-process` in a source checkout).

Call it first to check that the app is reachable and which plan is active; a refusal from any
other tool names the plan it needs. Needs Stochastly open with an Atelier or Portfolio licence.

### `backtest_graph` (~396 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Run a strategy graph end to end on your data: build the configurations, run a cost-aware
backtest with leakage-free splits, apply the overfitting gates and return the verdict, the
number of survivors and the run_id. Each finished run is added to the day's session registry,
and `multiplicity` reports how many runs and configurations this session has tried.

Check the plan with compose_graph first. Data comes from `data_root` or a registered
\`source`; nothing is downloaded for you and an unknown source is refused. A plan with custom
Python is refused unless the user allowed custom code on this machine. Use background=true for
long runs, then backtest_status. Requires an Atelier or Portfolio licence.

Input parameters:

- `background` (boolean): True returns a run_id at once; poll backtest_status for the result.
- `cap` (integer): Maximum number of parameter configurations evaluated.
- `data_root`: Folder holding your own price files.
- `direction` (string): Trade direction: "L" (long only), "S" (short only) or "LS" (both).
- `plan` (object, required): Strategy graph, same shape as in compose_graph; node keys come from node_catalog.
- `source` (string): Registered data source name from data_sources; "folder" reads data_root. An existing folder path given here is used as data_root.
- `symbols`: Symbols to trade; omit for the default universe, which the run names in its note.
- `tf` (string): Bar timeframe, for example "1h".
- `timeout_s` (integer): Seconds to wait for the result (minimum 5); after that, poll backtest_status.

### `backtest_status` (~170 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Get the state of a graph run started by backtest_graph: while running, status, progress and
message; once done, failed or cancelled, the same summary backtest_graph returns (verdict,
survivors, multiplicity).

Use it after backtest_graph with background=true, or when a foreground run hit its timeout.
A finished run is recorded once in the day's session registry. An unknown run_id is a named
error. Needs Stochastly open with an Atelier or Portfolio licence.

Input parameters:

- `run_id` (string, required): run_id returned by backtest_graph.

### `compose_graph` (~443 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Check a strategy graph plan and turn it into a run specification, counting how many
parameter configurations it would test. Nothing is executed and no data is read.

Use it to build and debug a plan before backtest_graph, which takes the same arguments.
Returns ok, configs, runnable, strategy, filters, gates and the full spec; an invalid plan
returns ok false with the exact field at fault. A plan carrying custom Python is reported in
\`custom_code_nodes` with `runnable_over_mcp`, since backtest_graph refuses it unless the user
allowed custom code. Strategy and filter params are single-value locks; omit one to sweep its
catalogue values. Gates take a threshold, op "ge" or "le", and window "oos", "is", "oos2",
"sealed", "full" or "wfa". Cost nodes charge the run; lectures are informational. Needs
Stochastly open with an Atelier or Portfolio licence.

Input parameters:

- `direction` (string): Trade direction: "L" (long only), "S" (short only) or "LS" (both); long, short, both and similar spellings are accepted.
- `plan` (object, required): Strategy graph. Keys: strategy {key, params, code}, filters [{key, params, code, mode}], gates [{key, threshold, params, op, window}], lectures [{key, params}], execution {..}, data {is_pct, oos1_pct…
- `symbols`: Symbols to trade; omit for the default universe.
- `tf` (string): Bar timeframe, for example "1h".

### `crypto_registry` (~129 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

List the cross-sectional crypto strategies (momentum and mean reversion) with their
timeframes, directions, parameter grids and filters; each entry carries an `implemented` flag.

Use it to see which crypto ranking strategies exist. For graph node keys use node_catalog;
for the general strategy families use registries. Needs Stochastly open with an Atelier or
Portfolio licence.

### `data_sources` (~141 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

List the data source names registered in this build, as `sources`; "folder" (a folder of
your own price files) is always one of them.

Use it before backtest_graph to pick its `source` argument. A source missing from this list
is not available: pass `data_root` (a folder of price files) to backtest_graph instead.
Needs Stochastly open with an Atelier or Portfolio licence.

### `diagnostic_explain` (~165 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Explain one diagnostic code: what the quantity measures, why it matters, and which
measurement could move the verdict (never a promise that an action will improve it).

Use it on codes returned by red_flag_check; list every code with diagnostics_catalog. An
unknown code returns an error with the list of known codes. Needs Stochastly open with an
Atelier or Portfolio licence.

Input parameters:

- `code` (string, required): Diagnostic code such as "OF01", "OF03" or "CO01", as returned in red_flag_check `violations`.

### `diagnostics_catalog` (~125 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

List every diagnostic code the app can raise, as `diagnostics` (code, family, page) and
\`severities`.

Use it to know what the checks can hold against a run, and so what they cannot judge yet;
explain one code with diagnostic_explain. Needs Stochastly open with an Atelier or Portfolio
licence.

### `export_atlas` (~239 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Write one research paper PDF per finished run with a shared layout and title, and return
ok, dir, n, papers ({name, path, pages, rank, or error} each) and failed.

Use it to report several runs consistently; export_paper handles a single run. Every paper
prints how many papers the batch contains, because producing N reports is N trials. Every
run must be finished and carry a verdict, otherwise nothing is written; a paper that fails
to render is listed with its error. Requires an Atelier or Portfolio licence.

Input parameters:

- `layout`: Ordered section ids from paper_sections, shared by every paper.
- `out_dir`: Output folder; files with the same names are overwritten. Omit for a new folder in the app's papers folder.
- `run_ids` (array, required): Ids of the finished runs, one paper each.
- `title`: Title shared by every paper.

### `export_paper` (~281 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Write a multi-page research paper PDF for one finished backtest run: abstract, numbered
equations, tables, robustness section and a mandatory backtest disclosures box. Returns ok,
path, pages, figures, tables, omitted and the layout actually printed.

Use it for a full write-up of one run; export_tearsheet makes a one-page summary and
export_atlas a batch of papers. Every number comes from the run; a section whose data the run
lacks is omitted with a note, and an unknown layout id is an error. Requires an Atelier or
Portfolio licence.

Input parameters:

- `hypothesis`: The hypothesis registered before the search. Only pass it if that is true; without it the paper is labelled exploratory.
- `instrument`: Instrument name printed on the paper.
- `layout`: Ordered section ids from paper_sections; omit for the default paper.
- `path`: Output PDF path; an existing file there is overwritten. Omit for a new time-stamped file in the app's results folder.
- `run_id` (string, required): Id of a finished backtest run.
- `title`: Paper title.

### `export_tearsheet` (~191 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Write a one-page tearsheet image or PDF summarising a finished run, and return ok, path and
fmt.

Use it for a quick shareable summary; export_paper writes the full paper. Research runs have
no tearsheet and are refused, as are unknown or unfinished runs. Requires an Atelier or
Portfolio licence.

Input parameters:

- `fmt` (string): "png" or "pdf"; any other value gives png.
- `path`: Output file path; an existing file there is overwritten. Omit for tearsheet_<run_id> in the app's tearsheets folder.
- `run_id` (string, required): Id of a finished backtest, ML or portfolio run.

### `live_state` (~162 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Read what the open app last reported it is showing (workspace, chart, symbol, timeframe,
indicators, graph nodes, current run, active assistant agent; never secrets) from its state
file, with `age_s` (seconds since it was written) and `present` (false when the app has never
written it).

Use it to check the effect of pilot_app or the context of the user's screen. A large age_s
means the app is probably closed. Needs Stochastly open with an Atelier or Portfolio licence.

### `node_catalog` (~262 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Return the graph editor's node catalogue. Without `family`: an index with one line per
node, `family/name [status](parameter names)`, grouped by list, plus counts and timeframes.
With `family`: the full schema of that family's nodes (values, defaults, symbol limits,
notes, an `exportable` flag on strategies).

This is the only source of valid node keys ("family/name") for compose_graph and
backtest_graph; call it before writing a plan, then once per family you use. The index note
says which status cannot be placed. Needs Stochastly open with an Atelier or Portfolio licence.

Input parameters:

- `family`: A list or family name from the index (for example "strategies", "filter", "cost", "ml"); returns that family's full parameter schemas. Omit for the index of every node.
- `force` (boolean): True reloads the catalogue from the engine instead of the in-memory copy; only needed after the engine was updated while the app was open.

### `paper_sections` (~143 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

List every section a research paper can contain, each as {id, group, label, mandatory,
in_default}, default sections first in print order.

Use it to choose the `layout` ids for export_paper or export_atlas. Mandatory sections (the
simulation letterhead and the backtest disclosures) are always added back, and the paper
follows the order you pass. Needs Stochastly open with an Atelier or Portfolio licence.

### `pilot_app` (~412 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Drive the open Stochastly app on the user's screen: open a .stly document, switch screen,
show a chart, start a backtest, display a note or send a prompt to the in-app assistant.
Fields combine in one call and apply in the order open, screen, chart, run; the user sees
each step in the status bar and the session journal.

Use it when the user should watch the work in the app; to run a graph and get its numbers
back directly, use backtest_graph. The command replaces any pending one. It has no effect
unless the app is open and the user enabled piloting (off by default); the response always
carries `pilot_enabled`. Requires an Atelier or Portfolio licence.

Input parameters:

- `chart`: Chart key to show in the display panel.
- `note`: Message shown to the user on screen; say what you are doing and why.
- `prompt`: Text for the in-app assistant, or a command: /verdict <hypothesis>, /research [@agent...] [rounds=N] [budget=N] <topic>, /stop. Cannot be combined with run.
- `run` (boolean): True starts a backtest on the graph in place. Cannot be combined with prompt. Refused for a document with custom Python unless the user allowed it.
- `session_path`: Path to a .stly document (at most 8 MB) to open in the Build screen. Only a summary of it comes back, never its content.
- `sym`: Legacy symbol field, ignored by the current app.
- `tf`: Legacy timeframe field, ignored by the current app.
- `workspace`: Screen to switch to: Home, Build, Backtest, Analyze, Results or Research.

### `portfolio_combine` (~467 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Combine several finished runs into one portfolio (book) and judge it: returns the numerical
correlation matrix between sleeves, simultaneous-loss days and percentage on common calendar
days, the correlation on the worst 5% of portfolio days, each sleeve's contribution, a
deflated Sharpe ratio, and the head and tail of the combined series and weights. Stressed
correlation is null if fewer than two selected days or zero variance prevent estimation.
The book is saved as a new run, so adversarial_check and export_tearsheet accept its run_id
and read the full series.

Use it for a multi-strategy or multi-market book; a single graph run covers one strategy, and
analyze_dependence only measures two curves you supply. Weights at bar t use only bars before
t, and the drawdown cap acts on the previous bar's equity. Nothing is re-simulated: runs must
be finished in the current app session; runs in different PnL units are refused, not
converted. Requires a Portfolio licence (Atelier gets a named refusal).

Input parameters:

- `dd_cap` (number): Drawdown at which the book is de-levered; 0 turns it off.
- `dd_derisk` (number): Leverage multiplier applied once dd_cap is reached.
- `lookback` (integer): Trailing window in bars used to estimate weights.
- `max_leverage` (number): Upper bound on the book's leverage.
- `method` (string): Weighting: equal weights, volatility targeting, risk parity, or hierarchical risk parity.
- `n_trials` (integer): Number of candidate sleeves to deflate the Sharpe ratio by; 0 uses the number of runs passed.
- `rebalance` (integer): Bars between two weight updates.
- `run_ids` (string): Comma-separated ids of at least 2 finished runs from this app session (a unique prefix is enough).
- `vol_target` (number): Target volatility per bar for the whole book; 0 turns it off.

### `reality_check_profiles` (~137 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Return the three synthetic example profiles of the reality check screen (profitable,
marginal, overfit) and the prop-firm rule presets it can apply (FTMO Standard and Pro 100k
phase 1, The5ers Hyper Growth).

Reference data only: to judge a real result use red_flag_check or adversarial_check. Needs
Stochastly open with an Atelier or Portfolio licence.

### `red_flag_check` (~343 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Combine five overfitting measures into one deployment verdict, GREEN, AMBER or RED, with a
score from 0 (no red flag) to 100 (severe); RED sets `deploy_blocked`. Also returns each component and its contribution,
reasons, `violations` (diagnostic codes with severity), which measures were missing, and the
coverage needed for GREEN.

Use it to decide whether a configuration or run is fit to deploy. Pass null for anything you
did not measure: missing evidence lowers coverage instead of being guessed. Explain a code
from `violations` with diagnostic_explain; to try to refute a finished run, use
adversarial_check. Needs Stochastly open with an Atelier or Portfolio licence.

Input parameters:

- `dsr` (required): Deflated Sharpe ratio of the result; null if not measured.
- `oos_is_sharpe_ratio` (required): Out-of-sample Sharpe divided by in-sample Sharpe; null if not measured.
- `realization_ratio` (required): Real PnL divided by theoretical PnL, after frictions; null if not measured.
- `selection_score` (required): Multiple-testing adjusted p-value (Romano-Wolf) returned by every run in `selection.score`; lower is better. null if not measured.
- `slippage_sens_delta` (required): Change in realization_ratio when frictions are multiplied by 1.5; null if not measured.

### `registries` (~147 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

List the strategy families, instrument groups and timeframes ("15M", "30M", "1H") the
app's built-in scanner screens are populated from, as `strategy_families`,
\`instrument_groups` and `timeframes`.

For the node keys you pass to compose_graph or backtest_graph, use node_catalog instead;
for the cross-sectional crypto strategies, use crypto_registry. Needs Stochastly open with an
Atelier or Portfolio licence.

### `research_status` (~200 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Read the saved journal of an in-app Research session: its status, turns, ideas, evidence,
token count and errors, with `age_s` since it was last saved.

Start a session with pilot_app(prompt="/research ...") and stop it with
pilot_app(prompt="/stop"). The journal is saved at start, after each turn and at the end,
so a `running` status is a checkpoint, not proof the session is still alive. Returns
\`present: false` when no session exists. Needs Stochastly open with an Atelier or Portfolio
licence.

Input parameters:

- `session_id`: Journal id (lowercase letters, digits and dashes, no path or extension). Omit for the most recent session.

### `run_smoke_tests` (~176 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Development only: start the Playwright smoke test of the app interface (visual regression and
a clean console, headless, on mocked test data) and return pass or fail with the diagnostic line.

It needs a source checkout with its test harness installed. An installed app does not ship it,
so there the tool returns `dev_only: true` and starts nothing. Requires an Atelier or Portfolio
licence.

Input parameters:

- `spec` (string): Playwright spec file name inside the checkout's tests folder.
- `timeout_s` (integer): Seconds before the test process tree is killed and a failure is returned.

### `set_live_state` (~175 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Legacy: queue a command asking the old chart terminal to show another symbol or timeframe.
The current app does not apply these two fields, and the response says so.

To drive the current app (open a document, switch screen, start a backtest) use pilot_app.
The command replaces any pending one and only takes effect when piloting is enabled
(`pilot_enabled` in the response). Requires an Atelier or Portfolio licence.

Input parameters:

- `sym`: Symbol for the legacy chart terminal, for example "BTCUSDT".
- `tf`: Timeframe for the legacy chart terminal, for example "1h".

### `tail_app_log` (~158 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Return the last lines of the app's own log file, with `present`, `age_s` and, when the log
is older than one hour, `stale: true` and a note saying it may describe an earlier session.

Use it to diagnose an app error. For a batch scanner run use v9_tail_log; for a graph run use
backtest_status. Needs Stochastly open with an Atelier or Portfolio licence.

Input parameters:

- `lines` (integer): Number of trailing log lines to return.

### `v9_get_run` (~173 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Read one batch scanner run: its verdict file, the robustness counts (n_total,
n_robust_pass), its PBO and the last 30 log lines.

Use v9_list_runs first to find the run_id, and v9_tail_log for more log lines. Errors are
named: `no_runs` when nothing has run, `run_not_found` for an unknown id. Needs Stochastly
open with an Atelier or Portfolio licence.

Input parameters:

- `run_id` (string): A run_id from v9_list_runs, or "latest" for the newest run.

### `v9_list_runs` (~192 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

List the runs of the separate batch strategy scanner (run folders named V9_* or V95_*),
newest first, each with run_id, status (running, done or error) and a summary (verdict,
n_configs, pbo_cscv, auc, best_config).

Use it to find a run_id for v9_get_run or v9_tail_log. Runs started from a graph are not
listed here: use backtest_status for those. Returns an empty list when the scanner is not
installed on this machine. Needs Stochastly open with an Atelier or Portfolio licence.

Input parameters:

- `limit` (integer): Maximum number of runs returned, newest first.

### `v9_protocol_a` (~155 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Summarise the batch scanner's saved regression check: how many baseline configurations its
current engine reproduces from the previous one, as n_total, n_strict (exact matches), n_soft
(within tolerance), n_cumul, pct_cumul and the tolerance used.

It reads a result file computed earlier by the scanner and starts nothing. Returns the error
\`no_protocol_a_results` when that file does not exist. Needs Stochastly open with an Atelier
or Portfolio licence.

### `v9_tail_log` (~170 tokens)

Requires the Stochastly desktop app: this tool runs inside the app, which is not installed on this machine. Request access at https://stochastly.com/request-access, then install and open the app.

Return the last lines of a batch scanner run's log file, as `lines`.

Use it to follow a running scan or see why one failed; v9_get_run gives the verdict and
robustness counts. An empty list means no run or no log yet. Needs Stochastly open with an
Atelier or Portfolio licence.

Input parameters:

- `lines` (integer): Number of trailing log lines to return; must be 0 or more.
- `run_id` (string): A run_id from v9_list_runs, or "latest" for the newest run.

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/com-stochastly-desktop/stochastly-mcp#diagnostics

## Score history

- 2026-11-05: 82
- 2026-11-04: 67
- 2026-11-03: 82
- 2026-11-02: 67
- 2026-11-01: 82
- 2026-10-31: 66
- 2026-10-30: 81
- 2026-10-29: 66
- 2026-10-28: 65
- 2026-10-27: 80
- 2026-10-26: 79
- 2026-10-25: 64
- 2026-10-24: 78
- 2026-10-23: 78
- 2026-10-22: 77
- 2026-10-21: 77
- 2026-10-20: 76
- 2026-10-19: 76
- 2026-10-18: 60
- 2026-10-17: 70
- 2026-10-16: 69
- 2026-10-15: 74
- 2026-10-14: 74
- 2026-10-13: 39
- 2026-10-12: 39
- 2026-10-04: 64
- 2026-10-03: 49

## Common questions

### What is the Stochastly Desktop MCP server?

Stochastly Desktop is an MCP server listed in the public MCP registry as com.stochastly/desktop. Local MCP access to Stochastly desktop nodes, diagnostics and research tools. This page covers its PyPI package (stochastly-mcp).

### Is the Stochastly Desktop MCP server safe to use?

Stochastly Desktop scores 82 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Stochastly Desktop MCP server expose?

Stochastly Desktop exposes 29 tools: adversarial_check, analyze_dependence, app_info, backtest_graph, backtest_status, and 24 more. Their descriptions and schemas cost roughly 6,555 tokens of context every time the server is loaded.

### Is the Stochastly Desktop MCP server still maintained?

Stochastly Desktop is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Stochastly Desktop MCP server under?

Stochastly Desktop declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- PyPI project: https://pypi.org/project/stochastly-mcp/
- Socket report: https://socket.dev/pypi/package/stochastly-mcp
- Repository: https://github.com/Stochastly/stochastly-mcp
- Website: https://stochastly.com/product/mcp
- Changelog RSS feed: https://verifymcp.io/servers/com-stochastly-desktop/stochastly-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-stochastly-desktop/stochastly-mcp.json
- HTML version of this page: https://verifymcp.io/servers/com-stochastly-desktop/stochastly-mcp