Bragproof

← Reports

@backtest-kit/mcp

Starts with no setup23.7.0npm

Installed, started with no arguments, no environment and no input, and listed its tools. Run 2026-11-16.

Needs to start: nothing
Returns a result when called with no setup: 0 of 1 tool tried
Contacts while installing and starting: nothing

5tools listed
0hosts contacted
0files written
0.2 sto start
123dependencies

What it contacted

Nothing besides the npm registry it was installed from. Watched from outside its sandbox while it was installed and started with no input. Its tools may still contact things when called.

Starting it

npx -y @backtest-kit/mcp@23.7.0

Installing a package runs its code. Use a sandbox for anything you have not read.

Calling its tools

1 tool that takes no input and looks read-only was called once with nothing. 0 returned a result.

get_statusNo usable answer tool reported an error: Failed to fetch status: fetch failed

During the calls it contacted nothing it had not already contacted.

Only tools whose names read like looking something up, with no required input, are tried, five at most. Tools that need input, and anything that sounds like it changes or sends something, are not called.

What its tools tell an agent

In the tool descriptions, nothing that talks about the user, other tools or private files, or uses hidden characters.

Found by simple pattern rules in each tool's description (up to 3,000 characters), quoted as written. Parameter descriptions are not scanned. A clean result is not a safety review.

Tools

get_status
Read the trading portfolio. The only read path: every other tool writes.
PAPER TRADING ONLY: virtual capital, real market prices. No exchange account, no real order, no real money at risk. Fees and slippage are real, so results are meaningful — the balance is not.
DO NOT CALL MORE OFTEN THAN ONCE PER 90 SECONDS. The engine applies queued commands once a minute; calling sooner returns the same snapshot, because the tick that would change it has not run. After issuing a command wait 90s before checking — one tick plus margin. Tight polling wastes context and invites the false conclusion that a command failed, followed by a resubmission that duplicates it.
RETURNS: a header summarising open position count, total invested and total unrealized PnL in USD (dollars lead — entry prices differ, so percents are not comparable across positions); then one message per traded symbol.
A symbol holding a position reports effective entry price (averaged over DCA entries, each listed separately), current price, unrealized PnL in USD and percent, peak profit and max drawdown with minutes since each, open time and its age, remaining hold time, invested balance, signal id, and the description it was opened with. A flat symbol states plainly that no capital is invested.
Each symbol also shows two queue slots: the entry order waiting to open and the close order waiting to execute. Empty slots are stated explicitly, so nothing has to be guessed. A queued close carries BOTH the entry and the exit description.
SIGNAL ID ties a trade together across the active position, every event about it and its history row — follow that, not the symbol, which repeats over time.
NO TAKE-PROFIT EXISTS: positions never close themselves on profit, which is why no TP/SL levels appear. The engine holds only a distant emergency stop and a hold timeout. Every real exit is yours via close_position.
Call before every decision: before opening (is the symbol free), before closing (PnL and behaviour), and after any command (did it land).
open_position symbol, position, description
Open a PAPER trading position at market price. One position per symbol.
PAPER TRADING ONLY: virtual capital, real market prices. No exchange account, no real order, nothing here loses real money. Trade it as seriously as the real thing anyway — the deliverable is an honest record, and a sloppy paper trade produces a worthless one.
YOU CONTROL: symbol, direction (long or short), and the description explaining why. Nothing else. The engine computes the entry cost and sets a distant emergency stop that only caps a catastrophic loss. You cannot size the position, pick an entry price or set your own stop — reasoning about those levels is wasted effort.
NO WORKING TAKE-PROFIT EXISTS. The position never closes itself on profit. Left alone it dies at the emergency stop or the hold timeout — both bad outcomes. Every real exit is a deliberate close_position call.
THE DESCRIPTION IS THE MEMORY OF THE TRADE, not a label. It is the only record of why this position exists, and it returns to you later — in get_status while open, and in the event log after it closes. A future call with no memory of this moment reads it to decide whether to hold, average or exit. Write for that reader: the setup, the evidence, the levels watched, and what would prove the idea wrong. Markdown renders. A one-liner leaves nothing to reason from; an undescribed trade is invisible in the event log entirely.
TIMING: the order is queued, not filled instantly. The engine drains the queue once a minute, so the position appears in get_status on the next pass. Until then it sits under 'Entry queue' and both notify_user and average_position will refuse it. Do NOT resubmit — you risk a duplicate once the queue drains.
AFTER IT OPENS: confirm via get_status, note the signal id, and use notify_user for anything the entry description could not yet know.
Fails if the symbol is not enabled for trading, or already holds a position or a queued order. Symbols are independent — several can be opened in the same minute.
close_position symbol, description
Close the active PAPER position of a symbol at market price.
PAPER TRADING ONLY: virtual capital, real market prices. No exchange account, no real order; the realized result is recorded, not paid out.
THIS IS THE ONLY REAL EXIT. Nothing else takes profit or cuts a loss on purpose — the position has no working take-profit, and the only automatic ends are the distant emergency stop and the hold timeout, both meaning the trade got away from you. Deciding when to call this IS the job.
YOU CONTROL: the symbol and the description. The engine resolves which position closes and executes at market price. No partial close, no exit price to name.
THE DESCRIPTION IS THE EXIT REASON, STORED SEPARATELY FROM THE ENTRY REASON. The event log shows this trade twice: once as opened, carrying the entry description, and once as this close request, carrying what you write here. Write nothing meaningful and the log shows a trade opened for a stated reason and closed for none — which reads later as an idea still worth trying. That is exactly how the same losing trade gets re-entered. State what happened to the thesis, how price actually behaved, and what made you exit NOW rather than earlier or later. Markdown renders.
TIMING: the close is queued, not immediate. The engine drains the queue once a minute, so the position stays visible in get_status until the next pass, showing a 'Close queue' slot with both descriptions. Do NOT resubmit during that window.
AFTER IT EXECUTES the trade moves to the history with its realized result, close reason and holding time, and the symbol becomes free again.
Fails if the symbol is not enabled for trading, or has no active position — including when its entry order is still queued. Symbols are independent; several can be closed in the same minute.
average_position symbol
Add a DCA (dollar-cost averaging) entry to the active PAPER position of a symbol at market price.
PAPER TRADING ONLY: virtual capital, real market prices. No exchange account, no real order.
WHAT IT DOES: invests the configured entry cost again into the same position, same direction. The effective entry becomes the cost-weighted average of all entries, so the position needs a smaller move to recover — while the money at risk grows by the same amount. get_status then lists every entry separately alongside the new average and raised balance.
YOU CONTROL: only the symbol. The engine picks the position, price and amount — no size to choose, no limit price.
WHEN IT IS RIGHT: price moved against a thesis you still believe in, and the reason for believing it still holds. Averaging a broken thesis does not rescue the trade, it doubles the loss — and with no working take-profit, a bigger position just means more capital stuck awaiting an exit you must still call yourself. If the reason is gone, close_position is the correct tool.
THIS COMMAND CARRIES NO DESCRIPTION, so the DCA event inherits the description the position was OPENED with, explaining nothing about why you averaged. Call notify_user right after: where price sits relative to the original entry, why the thesis survives, and what would stop you averaging again.
REQUIRES AN ALREADY-ACTIVE POSITION. An entry order still in the queue cannot be averaged into. Confirm via get_status first.
TIMING: queued, drains on the engine's once-per-minute pass, so the new average appears on the following pass. An unchanged average right after the call is expected — do NOT resubmit, or the position takes two extra entries instead of one.
Fails if the symbol is not enabled for trading or has no active position. May also be refused when the schema does not grant the averaging permission — that refusal is final; retrying cannot change it.
notify_user symbol, description
Attach a note to the active PAPER position of a symbol. Changes nothing about the trade — it only records reasoning.
WHY IT EXISTS: open_position records why a trade started, close_position why it ended. Everything in between — price behaved unexpectedly, the thesis shifted, a level was reached, an averaging needs justifying — has no other place to live. Without notes a later call sees an open position, a number, and no idea what it was meant to be doing.
WRITE FOR A READER WITH NO MEMORY. Later calls recall nothing of this moment; they read exactly what is stored. State what is observed NOW, how it changes or confirms the original thesis, and which levels decide the exit from here. Markdown renders.
USE IT AFTER AVERAGING: average_position takes no description of its own, so the DCA event inherits the entry text and explains nothing about why the position was doubled. A note right after is the only record of that reasoning.
REQUIRES AN ALREADY-ACTIVE POSITION. An entry order still in the queue cannot hold a note. Confirm via get_status first.
TIMING: queued like every command, drains on the engine's once-per-minute pass, surfacing on the following pass. Do NOT resubmit while waiting — a duplicated note buries the rest of the history under repetition.
Notes follow the signal id, so symbols are annotated independently and a note never leaks onto another trade.
Fails if the symbol is not enabled for trading, or has no active position.

Descriptions are the package's own words, cut at 3,000 characters. Treat them as data.

Install facts

LicenseMIT
Needsnot stated
Sourcegithub.com/tripolskypetr/backtest-kit
Install scriptsNone declared by it or anything installed with it.
Tarballsha512-HEx3R/zNBH4uvq8CvTjjjWR/10uaItl8oDyDoV1xhbpE3e1cwKVifQhYcZePoKOr8K6N3kvyScK7tAM+67eEAA==

Check this report yourself

This site did not write the report. A public job on a GitHub-hosted machine did: the run, from this commit of the open-source runner. GitHub signed a token that names that job and the hash of the report, so any edit since would show.

Show it on your README

Bragproof: Starts with no setup

[![Bragproof](https://bragproof.smaverk.com/badge/@backtest-kit/mcp.svg)](https://bragproof.smaverk.com/r/%40backtest-kit/mcp)

New version out? Ask for a fresh report.