MCP connector

Every tool, and what it does

All 50 Spera MCP tools grouped by what you would ask for, with the permission each one needs and whether it writes anything.

Updated 2026-08-26·Rev. 2026.06

Your assistant has 50 tools, 21 of which only read. You never call these yourself — you ask for an outcome and the assistant picks. This page exists so you can see exactly what it is able to do, and what each capability costs you in permissions.

Nothing here trades

There is no tool for deploying a bot, reading an exchange key, or moving money. That is not a setting — those tools do not exist on this server, so no phrasing reaches them.

Orientation and discovery

What your assistant calls first: who you are, what you already have, and what the node and SDK vocabulary is. Every one of these is read-only.

Tool	What it does	Permission	Writes
Get Spera context `spera_context_get`	Returns who you are, which projects you can reach, the contract version, and the limits in force. This is the first call in almost every workflow.	`spera:context:read`	No
Search artifacts `spera_artifacts_search`	Finds your strategies, modules, and custom nodes by name or content, paged.	`spera:artifact:read`	No
Get one artifact `spera_artifact_get`	Reads a single artifact at an exact revision, including its graph and dependencies. Defaults to the artifact's default branch; pass version.branchId to read any other strategy branch (its resolved commit is echoed back), or version.branchId plus version.commitId for one exact immutable commit. Branch addressing is strategy-only.	`spera:artifact:read`	No
Resume a workflow `spera_workflow_resume`	Picks a durable workflow back up where it stopped — the reason a long build survives a client restart or a new chat.	`spera:context:read`	No
Get the node catalog `spera_node_catalog_get`	A compact list of every node type available to build with — the assistant's vocabulary before it writes a graph.	`spera:artifact:read`	No
Get exact node schemas `spera_node_details_get`	The full schema for specific nodes: inputs, outputs, parameters, and defaults. Prevents invented config keys.	`spera:artifact:read`	No
List experiment branches `spera_strategy_branches_list`	Lists the experiment branches on a strategy, so a variant can be compared instead of overwriting the original.	`spera:artifact:read`	No
Search the custom-node SDK `spera_sdk_symbols_search`	Finds SDK symbols by name when writing a custom node, rather than guessing at an API.	`spera:artifact:read`	No
Get exact SDK symbols `spera_sdk_symbol_get`	Reads the exact signature and semantics of named SDK symbols.	`spera:artifact:read`	No

Strategies

Create, edit, and branch strategy graphs. Every write compiles, so a tool call that succeeds means the graph is valid — not merely saved.

Tool	What it does	Permission	Writes
Create a strategy `spera_strategy_create`	Creates a strategy graph and compiles it. Needs no existing project — one is created for you if you have none.	`spera:artifact:write`	Yes
Edit a strategy `spera_strategy_patch`	Applies a revision-checked edit and recompiles. If the strategy moved since it was read, the write is rejected rather than clobbering your change.	`spera:artifact:write`	Yes
Set backtest settings `spera_strategy_settings_set`	Changes the money model a strategy's backtests run under — starting balance, fees, slippage, margin and leverage, order sizing, and the risk rails (drawdown stops, exposure caps, daily loss, cash reserve, compounding). Send only the fields you are changing; the rest keep their current values, except the risk policy, which is always replaced whole ( turns it off). Once set, a backtest can omit settings entirely and inherit them. The same rails are enforced by the strategy's deployed paper and live bots.	`spera:artifact:write`	Yes
Branch a strategy `spera_strategy_branch_create`	Forks an experiment branch so a variant can be tried without touching the original.	`spera:artifact:write`	Yes

Modules

Reusable sub-graphs. Ports are set only after a clean compile, so a module's input/output contract can never describe a graph that does not build.

Tool	What it does	Permission	Writes
Create a module `spera_module_create`	Creates a reusable sub-graph and compiles it.	`spera:artifact:write`	Yes
Edit a module `spera_module_patch`	Applies a revision-checked edit to a module and recompiles.	`spera:artifact:write`	Yes
Set module ports `spera_module_ports_set`	Declares the module's input/output contract. Only accepted after a clean compile.	`spera:artifact:write`	Yes

Custom nodes

Structured custom nodes, edited through canonical plans and hashes rather than free-text patches, then compiled explicitly.

Tool	What it does	Permission	Writes
Create a custom node `spera_custom_node_create`	Creates a structured custom node from a canonical source.	`spera:artifact:write`	Yes
Get an edit plan `spera_custom_node_plan_get`	Returns the canonical plan and field hashes for an edit, so a patch targets exactly what was read.	`spera:artifact:write`	No
Edit a custom node `spera_custom_node_patch`	Applies a hash-checked edit to a custom node.	`spera:artifact:write`	Yes
Compile a custom node `spera_custom_node_compile`	Compiles explicitly and returns diagnostics. Compilation is never implied by a save.	`spera:artifact:write`	Yes

Backtests

Quick runs return inline; deep runs are durable jobs you poll, read in pages, and can cancel. Both bind to an exact revision, so a result always names the code that produced it.

Tool	What it does	Permission	Writes
Run a quick backtest `spera_backtest_quick_run`	Runs a bounded backtest against an exact revision and returns the result inline.	`spera:backtest:run`	Yes
Start a deep backtest `spera_backtest_deep_start`	Starts a durable job for a longer run. Returns a job id to poll rather than blocking.	`spera:backtest:run`	Yes
Check a backtest job `spera_backtest_get`	Reads a durable job's status and progress.	`spera:backtest:read`	No
Read backtest results `spera_backtest_results_get`	Reads trades, equity, and metrics in pages — the evidence behind any claim about performance. A universe run pages its plans; a Book pages its event log (why each coin joined, left, was resized or stopped).	`spera:backtest:read`	No
Cancel a backtest `spera_backtest_cancel`	Stops a running deep backtest.	`spera:backtest:cancel`	Yes
Compare branches in one run `spera_backtest_compare_start`	Backtests several branches of one strategy over the same window as a single job, with one ranked result. Costs one deep backtest per strategy run — the strategy plus each branch, template, and peer — and sidesteps the per-user concurrent-job limit that rejects firing them separately.	`spera:backtest:run`	Yes
Run the Edge Check `spera_edge_check_run`	Releases the three deferred robustness reads on a finished deep backtest — random entries, shuffled market, and parameter sensitivity. Costs no backtest run.	`spera:backtest:run`	Yes

Portfolios

Many (strategy x pair) legs held as one book and backtested together into a single combined equity curve. Distinct from a branch sweep, which ranks branches against each other rather than running them as one portfolio.

Tool	What it does	Permission	Writes
List portfolios `spera_portfolio_list`	Lists your saved portfolios as summaries — name, leg count, capital mode, and the last run's headline metrics.	`spera:artifact:read`	No
Read a portfolio `spera_portfolio_get`	Returns one portfolio in full: every leg with its pinned strategy revision, symbol, timeframe, capital slice, its own settings copy (flagged when the strategy has moved on since) and its own risk rails, plus the account (with the book's risk rails) and the revision you pass back when editing it.	`spera:artifact:read`	No
Create a portfolio `spera_portfolio_create`	Saves many (strategy x pair) legs as one book, or a Book of universe legs that trade a Universe's picks (hold the coins, or run a strategy on each). The same strategy may appear on several legs at different branches, and naming a branch pins its head to an immutable commit. Each strategy leg copies its strategy's settings and owns them from then on. Premium.	`spera:artifact:write`	Yes
Edit a portfolio `spera_portfolio_patch`	Changes a portfolio's legs, each leg's own settings and risk rails, the capital model, or the account and the book's risk rails. Requires the revision you last read, so an edit can never silently overwrite one made in the app meanwhile.	`spera:artifact:write`	Yes
Backtest a portfolio `spera_portfolio_backtest_start`	Runs every leg over one window and aggregates them into a single combined equity curve, with each leg's own metrics alongside. The book's risk rails are judged on the whole book and each leg's on its own contribution. A Book adds costs, idle capital, baselines against random pickers and a timing-luck read. Costs one deep backtest per leg (a Book is metered in coin-bars), reserved before the run starts.	`spera:backtest:run`	Yes

Universes

A Universe picks coins: a coin set filters the market, a picker ranks what is left, and a schedule decides when to pick again. It trades nothing on its own. Preview the coin table at any date, then check whether the ranking actually predicts returns before you build on it.

Tool	What it does	Permission	Writes
List universes `spera_universe_list`	Lists your saved universes as summaries — name, description, node count, and the current revision — plus the templates a new one can start from.	`spera:artifact:read`	No
Read a universe `spera_universe_get`	Returns one universe in full — its coin set, measures, picker, schedule, and trader — with its account and last backtest, plus the revision you pass back when editing it. Can read an older saved version.	`spera:artifact:read`	No
Create a universe `spera_universe_create`	Saves a new universe, from a template or a full design, with an optional account (capital, costs, order timing), and reports whether it builds. If it has errors, your assistant fixes them with an edit; if it builds, the next step is a preview.	`spera:artifact:write`	Yes
Edit a universe `spera_universe_patch`	Changes a universe with a batch of small edits that applies whole or not at all, or replaces its design outright; also changes its account, name, or description. Requires the revision you last read, so an edit can never silently overwrite one made in the app meanwhile.	`spera:artifact:write`	Yes
Preview a universe `spera_universe_preview`	Shows the coin table at one date: which coins were allowed, still warming up, or excluded and why, how each one scored and ranked, and which were picked at what weight. Costs one quick backtest.	`spera:backtest:run`	Yes
Check a universe's picker `spera_universe_picker_check`	Tests whether the ranking predicts returns over a window: how strong the signal is, how fast it fades, how often to re-pick once costs count, and whether the top picks are just riding Bitcoin. Costs one deep backtest.	`spera:backtest:run`	Yes
Check a universe edit `spera_universe_validate`	Checks whether a universe, or an edit to one, builds — without saving anything or spending any allowance — and says when it would next pick.	`spera:artifact:read`	No
Backtest a universe `spera_universe_backtest_start`	Runs a universe with its own account over a window and compares it with equal weight, holding Bitcoin, and random picks. Can quote the price first; the run costs deep backtests and needs a plan with portfolios.	`spera:backtest:run`	Yes

Research studies

Price the search, then judge once. A study counts every Spera backtest that competed for one research question, deflates the finalist's Sharpe by that count, and holds back a sealed window for a single final test. Studies are Spera-only: every trial is a run Spera executed.

Tool	What it does	Permission	Writes
Open a research study `spera_study_open`	Starts a study for one research question before exploring, and fixes its sealed window. While the study is open, every quick, deep, and branch-sweep run your assistant starts on that strategy is counted as a trial and refused if it reaches the sealed window.	`spera:artifact:write`	Yes
Read a research study `spera_study_get`	Reads one study, a project's studies, or the study a backtest belongs to — with that run's Deflated Sharpe: the chance its Sharpe is real once every competing trial is priced in.	`spera:backtest:read`	No
Run the sealed test `spera_study_evaluate`	Spends the study's one sealed window: re-runs the finalist over it and returns a verdict with its statistical power. Single use, and costs one deep backtest.	`spera:backtest:run`	Yes

Project knowledge

Project-scoped Markdown your assistant can cite. STRATEGY.md is protected: it takes a proposal and an explicit acceptance, never a direct write.

Tool	What it does	Permission	Writes
List project knowledge `spera_project_manifest_get`	Lists or searches the Markdown documents in a project.	`spera:knowledge:read`	No
Read a project document `spera_project_document_get`	Reads one document at an exact revision, so a quotation can be cited rather than paraphrased.	`spera:knowledge:read`	No
Write a project document `spera_project_document_apply`	Creates or revises an ordinary project document. Does not apply to `STRATEGY.md`.	`spera:knowledge:write`	Yes
Propose a STRATEGY.md change `spera_strategy_document_propose`	Opens a proposal against the protected `STRATEGY.md`. Nothing is written yet.	`spera:knowledge:write`	Yes
Accept a STRATEGY.md proposal `spera_strategy_document_accept`	Applies a proposal after you explicitly accept it. This is the only path that writes `STRATEGY.md`.	`spera:knowledge:write`	Yes

Artifact documentation

The docs attached to one strategy, module, or custom node — written against an exact revision and grounded in real compile or backtest receipts.

Tool	What it does	Permission	Writes
Read artifact documentation `spera_documentation_get`	Reads the documentation attached to an artifact at an exact revision.	`spera:documentation:read`	No
Write artifact documentation `spera_documentation_apply`	Writes documentation for an artifact, revision-checked and grounded in real receipts.	`spera:documentation:write`	Yes

How to read the permission column

Each tool names the single permission it needs. A read-only connection holds only spera:context:read and spera:artifact:read, so every tool needing anything else is simply absent from that session — not present and refusing. What you're approving walks through the full list.

If a tool you expected is missing, that is a permissions answer, not a bug: When it doesn't connect.