Spera

Create one stable-ID private module and compile its graph. A clean graph must be followed by one module-port configuration call.

spera_module_create

Create one stable-ID private strategy without requiring an existing project, apply a bounded graph patch, compile it, then create its owner-visible Project and return projectId. Retries are idempotent.

spera_strategy_create

Change a portfolio's name, description, legs, capital model or account. Every field is optional; `positions` and `capitalModel` REPLACE what is stored rather than merging, so send the full list you want — a capitalModel without rebalanceFrequency / rebalanceBandPercent clears the rebalancing policy, so copy them from the portfolio you read. A leg sent with its existing positionId and no `settings` keeps its settings copy; send `settings` to edit it, or syncSettingsFromStrategy: true to re-copy the strategy's current settings. `account` and each leg's riskPolicy are also replaced whole: a leg sent without riskPolicy loses its rails, and an account sent without riskPolicy turns the book's rails off, so resend what you read. expectedRevision is REQUIRED: read the portfolio first and pass the revision it returned. A portfolio has two writers — this tool and the owner's builder open in a browser — so a stale revision is refused with a conflict naming the current one, and the right response is to re-read and rebase, never to retry the same body.

spera_portfolio_patch

Read one exact authorized artifact. Owned writable strategies/modules include their bounded graph; modules also include a ready-to-copy moduleReference and exact input/output port handles for strategy embedding. Pass version to read a specific strategy revision instead of the default branch: version.branchId alone reads that branch HEAD and reports the concrete commitId back in artifact.version, and version.branchId + version.commitId reads that exact immutable commit. Branch ids come from spera_strategy_branches_list. version is strategy-only — modules are addressed by moduleVersion and custom nodes by their compiled revision, so sending it for those kinds is rejected rather than ignored.

spera_artifact_get

Return the authorized user, project context, explicit project-selection rules, contract version, capabilities, and limits. Call it only to start or refresh Spera strategy, module, custom-node, backtest, or project-knowledge work; never to check whether Spera can trade, quote prices, hold exchange credentials, or give investment advice (it cannot). For the initial call pass no arguments ({}). Empty project pages are valid and do not block strategy creation. For an edit, use an explicit or unique authorized Project; if multiple Projects are plausible, ask the user to select one by returned name and ID. To continue the project list, pass only nextCursor as cursor plus pageSize; pagination is output, not input.

spera_context_get

Return the current structured plan, source revision, source map, and per-field hashes required for safe edits.

spera_custom_node_plan_get

Read one caller-owned job with compact progress or summary, its exact reproducibility binding, recommended poll interval, expiry, and remaining poll budget.

spera_backtest_get

List compact node summaries. Fetch exact schemas only for node types selected for an authoring patch.

spera_node_catalog_get

Return exact signatures, constraints, and examples for up to ten selected custom-node SDK symbols.

spera_sdk_symbol_get

Return exact config, input, and output schemas for up to 20 selected node types.

spera_node_details_get

Read the bounded metadata-only manifest first, or search it by query and virtual path prefix without loading Markdown bodies.

spera_project_manifest_get

List this account's portfolios. A portfolio holds many (strategy x pair) legs that backtest TOGETHER as one book: one combined equity curve and one set of metrics, while each leg keeps its own. Returns summaries only (name, leg count, capital mode, last run); read one with spera_portfolio_get to get its legs and its revision.

spera_portfolio_list

List bounded branch heads for one exact authorized strategy so callers can bind edits and backtests to immutable versions.

spera_strategy_branches_list

Open a research study for ONE research question BEFORE you start exploring ideas for it. A study prices the search: every Spera backtest that competes for the question counts as a trial, the finalist's Sharpe is deflated by that count (the Deflated Sharpe), and a sealed window of recent history (or a future one) is held back for a single final test. Studies are SPERA-ONLY: every trial is a run Spera executed, so EVERY exploration run must go through Spera MCP — spera_backtest_quick_run, spera_backtest_deep_start, or spera_backtest_compare_start for variants. Never test ideas on a local engine, an off-platform backtest, or raw exchange candles: those runs are invisible to the study, so the finalist would clear a bar that ignores them. Open it first — runs made before the study opened are not counted. While the study explores, every quick, deep and compare run on the project's strategy is attached automatically, counted, and refused if it reaches past seal.explorationEnd (also explorationEndIso), the LATEST 'to' any exploration run may use. sealMode 'retrospective' (default) seals the most recent sealDays (default 180) of history; 'forward' seals a window that has not happened yet — provably unseen, but it can only be evaluated once the window has passed. One study per project may be open; STUDY_ALREADY_OPEN names it — read it with spera_study_get instead of opening another.

spera_study_open

Apply one revision-safe body or shape edit. Body edits require the exact current field hash and never compile implicitly.

spera_custom_node_patch

Patch one exact module revision and compile atomically. A clean graph must be followed by module-port configuration.

spera_module_patch

Patch one exact strategy revision and compile atomically. Compile repairs stay on the same draft; read-only artifacts fork when explicitly allowed.

spera_strategy_patch

Create one revision-pinned STRATEGY.md proposal for explicit user review; this does not apply the proposal.

spera_strategy_document_propose

Read research studies. Pass exactly ONE of: studyId (one study), projectId (that project's studies, open and closed), or jobId (the study a backtest belongs to, the run's role there — 'trial' or 'evaluation' — and its Deflated Sharpe; a quick-run or branch-sweep trial is addressed by its sample id from study.observedTrials). Read it with jobId on your finalist BEFORE spera_study_evaluate. selection.deflatedSharpe is the probability the run's Sharpe is real once the whole search is priced in (≥0.95 'survives_search', ≥0.50 'inconclusive', below 'likely_luck'); selection.probabilityBeforeSearch is the same statistic with no search priced in, so the gap between the two is what the search cost. selection.expectedMaxAnnualizedSharpe is the luck bar: the Sharpe the best of trials.effective zero-edge strategies would be expected to show by chance — the finalist must clear THAT, not zero. trials.effective is the number of independent trials the bar used: highly correlated runs collapse toward one, while runs Spera holds no daily sample for count whole. 'not_measurable' carries a reason and no statistics. While the study explores the read is live and moves as trials are added; after evaluation it is the snapshot frozen when the seal was spent. seal.explorationEnd is the latest 'to' any exploration run may use.

spera_study_get

Read Markdown documentation for one exact authorized strategy, module, or custom node and return its optimistic-concurrency revision.

spera_documentation_get

After completion, read the compact summary or one bounded page of trades, equity points, or diagnostics on demand. Deep jobs only: a comparison job's report returns inline from spera_backtest_get with kind:'compare', and has no paginated trade or equity artifacts.

spera_backtest_results_get

Read one exact virtual path or document ID, optionally by bounded line range, and return a revision-pinned citation.

spera_project_document_get

Read a portfolio in full: every leg with its strategy, pinned branch and commit, symbol, timeframe, capital slice, its OWN settings copy (costs, margin, sizing; settingsCopiedFrom says when it was copied, strategySettingsChanged is true when the strategy has moved on since) and its own riskPolicy, plus the account (currency, position mode, and riskPolicy for the whole book), the capital model and the last run summary. Returns `revision` — pass it straight back as expectedRevision on spera_portfolio_patch, which refuses a stale value instead of overwriting whoever wrote in between.

spera_portfolio_get

Reconstruct authoritative read-only workflow context after a client restart. No MCP session state is required.

spera_workflow_resume

Synchronously simulate one exact strategy commit over a bounded caller-supplied candle set. Returns a compact summary and never deploys.

spera_backtest_quick_run

Release the three deferred robustness reads on a COMPLETED deep-backtest job: whether the strategy beat randomly timed trades that copied its own trade count, side mix and holding periods; whether it still profits on the same candles dealt in a shuffled order; and whether neighbouring values of its numeric settings work too. Deep runs already carry the other five reads (out-of-sample, walk-forward, track record, trade-order, market conditions) — these three are deferred because each re-runs the money model many times over, so they are requested rather than automatic, and a run reports edgeCheck.status 'not_run' until you ask. Spends NO deep-backtest quota: nothing is re-simulated. Returns immediately by default and the verdicts land on the ordinary spera_backtest_get poll — a sweep can outlast any tool timeout, so pass waitSeconds only as a shortcut, never as the mechanism. Read the reports with spera_backtest_results_get(section:'edge'). If it is refused, report what happened: retrying starves other tenants' backtests.

spera_edge_check_run

Search authorized strategies, modules, and custom nodes. Results are bounded and contain stable identifiers.

spera_artifacts_search

Search the compact custom-node SDK catalog by query or category before requesting exact symbol details.

spera_sdk_symbols_search

Change the backtest settings (the money model a strategy's runs use: starting balance, fees, slippage, margin/leverage, order sizing, position mode, and the strategy's own risk rails) on one caller-owned strategy. PATCH SEMANTICS: send ONLY the fields you are changing under backtestSettings; every omitted field keeps its current value, and nested groups merge field-by-field — except riskPolicy, which is replaced whole (a policy is judged as a unit; send {} to turn the rails off). Read the current values from spera_artifact_get first. Leverage applies only when marginMode is "leverage" and the margin percents only when it is "margin_percent" — sending just a leverage switches the mode for you and reports it as a derived change, while sending a conflicting mode in the same call is rejected. Set resetToDefaults to restore the shipped defaults. Settings are stored out of band from the versioned graph, so this takes no expectedRevision and creates no commit. Once set, spera_backtest_quick_run / spera_backtest_deep_start can omit backtestSettings and inherit them.

spera_strategy_settings_set

Replace a compile-clean module input/output contract at an exact revision. Outputs must reference existing internal nodes and handles. Success returns the ready-to-copy moduleReference and complete port contract.

spera_module_ports_set

Run the ONE sealed test of an open research study: re-run the finalist — the study's completed DEEP-backtest trial named by inSampleJobId (quick-run and branch-sweep trials cannot be finalists), with its exact revision, symbol, timeframe and settings — over the sealed window nobody explored, and judge it against its exploration run. SINGLE USE: the seal is spent atomically when this call is accepted, the study stops accepting runs, and the Deflated Sharpe is snapshotted. Call it once, after exploration is finished and you have read the finalist's Deflated Sharpe with spera_study_get(jobId). Costs ONE deep backtest, reserved before it starts and refunded if refused. If it is refused, report the code and stop — never retry: STUDY_SEAL_SPENT (already evaluated), STUDY_SEAL_NOT_MATURED (a forward seal whose window has not passed), STUDY_FINALIST_NOT_A_TRIAL (run the finalist as a deep backtest under the study first), STUDY_FINALIST_NOT_DEEP (the named trial is a quick or sweep run — run it as a deep backtest under the study first), STUDY_FINALIST_NOT_COMPLETED, STUDY_FINALIST_NO_EVIDENCE, STUDY_FINALIST_STALE_ENGINE (a futures finalist measured before funding and bracket maintenance — re-run it as a deep backtest under the study and name that run; the seal is not spent), STUDY_SEAL_VIOLATION (the finalist's own run reached the seal), STUDY_NOT_EXPLORING. Poll the returned job with spera_backtest_get (artifactId and jobId from binding), then read report.sealedEvaluation. Its verdict: 'confirmed' — the sealed window alone shows a Sharpe above zero with ≥95% confidence; 'consistent' — not confirmed, but not significantly worse than exploration; 'did_not_hold' — sealed Sharpe ≤ 0, not significantly worse; 'contradicted' — significantly worse than exploration at 95%; 'insufficient_evidence' — under 30 daily observations or 20 trades. Always report powerAtInSampleSharpe with the verdict: a LOW power means this window was too short to confirm even a real edge of the exploration Sharpe, so it can falsify but mostly cannot confirm — 'consistent' then is not a pass. Report every run listed in integrity.sealTouchingJobs: a run that already saw the sealed window weakens the test.

spera_study_evaluate

Create or reuse one durable deep-backtest job bound to an exact strategy commit, market range, engine inputs, and normalized settings. Pass the strategy as top-level artifactId plus version.branchId/version.commitId; projectId and strategyId are not inputs. from, to and warmupFrom are Unix epoch MILLISECONDS (13 digits): 2024-01-01T00:00:00Z is 1704067200000.

spera_backtest_deep_start