KGSTUSDT * LowMoney

Modest positive return of 0.00% over the configured window. Max drawdown reached -0.00%, so the equity path was relatively contained.

KGSTUSDT | 5LowMoney.json | 2025-01-01 - 2025-12-31 | 0.00% | 0 closed trades

Headline Performance

Data source - GET /backtests/{id} + /equity + /trades * Fields used: return_pct, final_value, total_profit, win_rate, fulfilled_trades, active_orders, unrealized_pnl_exit_net, max_profit, min_profit

Return

0.00%

Final Value

10,000.00 USDT

Portfolio PnL

0.00 USDT (realized + unrealized)

Realized Profit

0.00 USDT (closed trades only)

Unrealized PnL

0.00 USDT (open positions, mark-to-market)

Win Rate (closed)

(excludes 0 open orders)

Closed Trades

Open Orders

Best Closed Trade

USDT

Worst Closed Trade

USDT

TL;DR

The LowMoney strategy on KGSTUSDT returned 0.00% over 2025-01-01 to 2025-12-31, turning 10,000.00 USDT into 10,000.00 USDT. Annualized growth (CAGR) was 0.00%.

Performance KPI Metrics

Data source - GET /backtests/{id} + /equity + /trades * Fields used: server aggregates from /daily-stats and /extras (Total Fees, Gross Profit/Loss, fill-type counts) plus <AnalyticsCharts> KPI strip * Transform: bt.* + dailyStats.totals + extras.deep_dive.fill_type_breakdown

Six-card KPI strip mirroring the live UI - combines risk (Max Drawdown, Sharpe), trade-economics (Profit Factor, Fees, Hold Time) and exit-mix (TP/SL/TSL) into one retrieval-friendly chunk.

Max Drawdown

-0.00%

Profit Factor

0.00

Sharpe Ratio

0.00

Total Fees

0.00 USDT

Avg Hold Time

0 min

TP / SL / TSL

0 / 0 / 0

Trade Economics

Metric	Value	Interpretation
Profit Factor	0.00	Sum of winning trades / sum of losing trades. >1 = profitable edge, >2 = strong, inf = no losses.
Gross Profit	0.00 USDT	Sum of all winning trades before fees.
Gross Loss	0.00 USDT	Absolute sum of all losing trades.
Total Fees	0.00 USDT	Buy + sell fees across all trades.
Fee Drag	-	What share of edge the exchange consumed.
Avg Hold Time	0 min	Mean duration a position is open.

Exit Mix (Fill Types)

Exit Type	Share	What It Means
TP (Take Profit)	-	Position closed by hitting the profit target - the desired outcome.
SL (Stop Loss)	-	Position closed by hitting the stop - capital preservation in action.
TSL (Trailing Stop)	-	Trailing stop locked in profit during a trend.

Verdict

For KGSTUSDT, the strategy’s profit factor of 0.00 means the strategy lost more than it won on a per-trade basis.

Chunking & Headings Guide

This document is structured for deterministic RAG ingestion. Each top-level section is wrapped in HTML-comment chunk markers and follows a stable heading convention.

Chunk markers

Every section is delimited by paired JSX comments - invisible to readers, trivial for splitters. (Earlier versions of this exporter used HTML comments; we switched to JSX comments in v2.4.0 because MDX 3 - the parser Mintlify uses - forbids HTML comments at the document level.) The example below uses uppercase RAG-CHUNK so it doesn’t accidentally match a splitter that scans this very page; real markers use lowercase rag-chunk:

{/* RAG-CHUNK:start id="tldr" type="summary" title="TL;DR" tokens~="120" backtest_id="1522e1a0-8523-4e5e-aa9d-a92c68269e5b" */}
...section markdown...
{/* RAG-CHUNK:end id="tldr" */}

Splitter rule: match the case-sensitive lowercase regex \{/\*\s*rag-chunk:(start|end)\b[^*]*\*/\} and treat everything between a matching start/end pair (same id) as one indivisible chunk. Never split inside a chunk. (For backwards compatibility with v2.3.x exports, splitters can OR-match the legacy regex .)

Heading convention

# Title - appears exactly once (the document title in the intro chunk).
## Section - opens every top-level chunk. Heading text matches the chunk’s title attribute.
### Sub-section - purely visual; never introduces a new chunk.
#### and deeper - reserved for inline detail (e.g. per-chart sub-blocks inside the catalogue).

Chunk `type` taxonomy

Type	Purpose	Best for retrieval of…
`meta`	Frontmatter & document intro	document-identity questions
`summary`	TL;DR-style condensed prose	”give me the headline”
`kpis`	Headline numbers, card grids	numeric lookups
`overview`	Tabular meta (period, balance, …)	“what was tested”
`comparison`	Strategy vs benchmark	”did it beat buy & hold”
`claims`	Assertion -> evidence -> source	citation-grade answers
`config`	Reproduction parameters	”how do I rerun this”
`chart`	Single visualization w/ embedded data	chart-specific questions
`catalogue`	Multi-chart bundle	exploratory chart questions
`risk` / `allocation` / `trade-stats` / `monthly` / `top-trades`	Domain-specific analytics	targeted KPI questions
`validation`	Data-quality report	trust / sanity questions
`facts`	Machine-readable JSON + key-value	deterministic lookups
`qa`	Pre-answered FAQ	direct Q&A retrieval
`glossary`	Term definitions	disambiguation
`narrative`	Human-oriented prose	”explain like I’m…”
`structured`	JSON-LD / schema.org	search-engine indexing
`provenance`	Metric -> API field -> formula lookup	”where does this number come from”
`integrity`	SHA-256 fingerprints of raw API payloads	tamper-evidence checks
`attachments`	Verbatim API responses + trade-sample CSV (full ledger via `/trades` pagination)	byte-level reproduction
`footer`	Disclaimers, links	compliance lookups

Recommended ingestion pipeline

Split on {/* rag-chunk:start ... */} / {/* rag-chunk:end ... */} boundaries.
Use the id attribute as the vector-store primary key - stable across re-exports.
Store type, title, tokens~, and backtest_id as filterable metadata.
Do not further chunk the facts, claims, qa, or structured sections - they’re designed to be retrieved whole.
The catalogue chunk is large; if your context budget is tight, split it on its ### sub-headings instead of dropping it.

Performance Analysis

Data source - GET /backtests/{id} + /equity + /trades * Fields used: same prose rendered on the live page by <BacktestInterpretation> - pure, deterministic, no LLM * Transform: buildBacktestInterpretation(bt)

Long-form, rule-based interpretation of this run. Identical to what the page shows - embedded here so an LLM can quote it verbatim without re-deriving the analysis.

This run produced a 0.00% return on KGSTUSDT - a small positive result. Outcomes in this range are within the noise band of typical backtest variance and should not be over-interpreted as evidence of edge. About KGSTUSDT: KGSTUSDT is a stablecoin-quoted spot pair on Binance. Quote-side liquidity is deep, so slippage assumptions in this backtest map reasonably well to live execution at retail size. About the LowMoney strategy: LowMoney is calibrated for small starting balances - smaller position sizes, tighter risk controls, fewer parallel orders. Configuration analysis: The LowMoney configuration entered on a 0.1% pullback signal across 2 potential buy splits at 3 USDT each. Total deployable notional is therefore 6 USDT - a position-sizing footprint that is defensive at 0% of starting capital - most of the account stays in stablecoins as buffer. No hard stop-loss is configured - the strategy relies on take-profit zones and trailing logic instead, which trades smoother behaviour for higher tail-risk in sustained downtrends. Profit is taken in 2 laddered sell zones, which scales out gradually rather than betting on a single exit price - a structure that smooths returns at the cost of capping the very best winners. Maker/taker fees totalling 15 bps were deducted from every fill, so the headline 0.00% is already net of trading costs - no additional fee adjustment is required when comparing to other runs. Over the configured 365-day window the strategy reported 0.00 USDT of realised trade profit on a 10000 USDT starting balance, ending at a portfolio value of 10000.00 USDT. Mechanically annualising the 0.00% window return projects to roughly +0.0% per year - the window covers roughly one full year, so the annualised figure is closer to the realised pace than to an extrapolation, but a single year still represents a single market regime. Treat this number as a unit-conversion of the window result, not as an expected forward return.

Methodology & data

This backtest was executed on historical Binance Spot 1-minute candles for KGSTUSDT, with intrabar fill simulation in “OLHC” mode and a synthetic order latency of 2s applied to each fill to approximate real-world routing delay. The simulator processes every minute sequentially, evaluates the LowMoney rule set, and books fills against the next available bar - a standard event-driven backtesting approach that avoids look-ahead bias. Equity is marked-to-market on every closed trade and aggregated into the equity curve shown above. Configured backtest window: approximately 12.0 months (365 days from config.from to config.to) of KGSTUSDT 1-minute price action - a sample size that is large enough to span multiple short-term regimes. Note: the equity series may cover fewer days if the engine omits leading or trailing flat periods (e.g. dates before the asset began trading); see the Overview section for the exact equity-coverage span.

Live trading considerations

Translating this result to live trading: KGSTUSDT is a deeply-liquid USDT-quoted pair on Binance, so the simulated fills here translate well to live execution at retail size. Lower trade frequency keeps slippage drag minimal, so live results should track the backtest more closely than a high-frequency configuration would. Without a hard stop-loss, the live system depends on the take-profit ladder firing during recovery legs; a prolonged downtrend without recovery will hold positions open longer than backtest aggregates suggest. Additionally, exchange downtime, API rate limits, and funding-rate changes (on perp variants) are not modelled here and should be accounted for in production deployment.

Frequently asked questions

Deterministic Q&A - every question is always present so this section can be sliced into stable RAG chunks. Missing API fields render as null; metrics that can’t be derived locally render as “not available”.

Is a 0.00% return on KGSTUSDT a good backtest result?

It is a positive but modest result; whether it is ‘good’ depends on what a buy-and-hold of KGSTUSDT produced over the same window and on the realised drawdown.

What is the annualised return for this KGSTUSDT backtest?

Compounding the 0.00% over 365 days projects to +0.0% per year. This is a directional indicator only - crypto regimes change, and strategies rarely sustain peak performance year-over-year.

Can I run this exact LowMoney configuration live?

The configuration shown in the Strategy Configuration block is the same JSON schema the live unCoded TradingBot consumes, so it can be loaded into a live instance. That is a technical compatibility statement, not a recommendation: a passing backtest is necessary but not sufficient evidence that a configuration will be profitable in live trading. Before any live use, validate on an out-of-sample window, paper-trade it, confirm exchange-side fees match the simulated 7.5/7.5 bps, and start with a position size well below the backtested capital to absorb live slippage and execution differences.

How is this backtest different from others on KGSTUSDT?

Every run on the platform uses the same intrabar-fill engine and historical Binance Spot data, so the comparison is apples-to-apples. What differs between runs is the LowMoney parameter set (buy trigger, sell zones, splits, stop-loss) and the time window - both are visible above so you can rerun, tune, or fork this configuration.

This interpretation is generated deterministically from this run’s own metrics. Past performance is not indicative of future results - a profitable backtest is necessary but not sufficient evidence that a strategy will work in live trading on KGSTUSDT.

Overview

Data source - GET /backtests/{id} * Fields used: symbol, mode_name, config.from, config.to, start_balance, final_value, avg_profit, status, created_at, started_at, completed_at, elapsed_sec, is_duplicate, data_file, id, summary_text

Field	Value
Trading Pair	`KGSTUSDT`
Strategy	LowMoney
Period	2025-01-01 -> 2025-12-31
Configured window (inclusive elapsed)	365.0 days (1.00 years) - `(config.to - config.from) / 86 400 000 ms`
Configured window (calendar days)	365 days - `Math.round` of the elapsed value above; this is what the narrative paragraph quotes
Equity-stat duration	7.0 days (0.02 years) - first -> last equity sample timestamp; used for CAGR / Sharpe / Sortino
Coverage gap	configured window is 365.0 days but equity samples span only 7.0 days - the engine omitted leading/trailing flat periods (e.g. dates before the asset began trading on the venue)
Start Balance	10,000.00 USDT
Final Value	10,000.00 USDT
Avg Profit / Trade	- USDT
Status	`completed`
Created	2026-04-19 12:41:49 UTC
Started	2026-04-19 16:37:10 UTC
Completed	2026-04-19 16:39:04 UTC
Compute Time	1.7s
Backtest ID	`1522e1a0-8523-4e5e-aa9d-a92c68269e5b`
Engine summary:

Backtest KGSTUSDT (Mode: 5LowMoney.json)
Period: 2025-01-01 00:00:01 to 2025-12-31 23:59:59
Starting balance: 10,000.00 USDT
Final value: 10,000.00 USDT
P&L: +0.00 USDT (+0.00%)
Result: PROFIT
Completed trades: 0
Open orders at end: 0

Strategy parameters:
  Buy trigger: -0.1% from last buy
  Buy splits: 2
  Sell targets: [0.25, 0.3]
  Investment per buy: 3.0 USDT
  Fees: maker 7.5 bps / taker 7.5 bps

Elapsed: 1.7s

Verifiable Claims

Each claim is grounded in a specific field + source so an LLM can cite evidence rather than paraphrase.

Claim	Evidence	Source
Strategy returned 0.00% over the tested window	`return_pct = 0`	`GET /backtests/{id} -> return_pct`
Capital grew from 10,000.00 to 10,000.00 USDT	`final_value - start_balance = 0.00 USDT`	`GET /backtests/{id} -> start_balance, final_value`
Worst peak-to-trough loss was 0.00%	`max_drawdown_pct = 0.0000`	derived client-side from /equity series

Strategy Configuration

Data source - GET /backtests/{id} * Fields used: mode_name, config (full JSON payload)

Mode LowMoney governs how buy triggers, position sizing and exits behave. Below are the exact parameters used for this run.

Highlights
Full JSON

Parameter	Value
`canBuy`	true
`canSell`	true
`canBuyUp`	true
`startBal`	10000
`stepSize`	1
`stopLoss`	false
`tickSize`	0.00001
`buySplits`	2

{
  "to": "2025-12-31 23:59:59",
  "from": "2025-01-01 00:00:01",
  "canBuy": true,
  "symbol": "KGSTUSDT",
  "canSell": true,
  "canBuyUp": true,
  "startBal": 10000,
  "stepSize": 1,
  "stopLoss": false,
  "tickSize": 0.00001,
  "buySplits": 2,
  "buyVolumes": [
    50,
    50
  ],
  "canBuyDown": false,
  "minNotional": 5,
  "buyPercentage": 0.1,
  "fees_in_quote": true,
  "intrabar_mode": "OLHC",
  "maker_fee_bps": 7.5,
  "taker_fee_bps": 7.5,
  "sellPercentages": [
    0.25,
    0.3
  ],
  "triggerCoolDown": 1,
  "investmentPerBuy": 3,
  "assumed_spread_bps": 0,
  "stopLossPercentage": 5,
  "investmentPercentMode": false,
  "minInvestmentPerQuote": 3,
  "order_latency_seconds": 2,
  "trailingStopLossPercentages": [
    0,
    0
  ],
  "sellCancelDistancePercentage": 1,
  "dontBuyBelowQuoteAssetBalance": 1,
  "investmentPerFreeQuotePercent": 0.01,
  "sellActivateDistancePercentage": 0.1
}

Full Mode Configuration

Every parameter the strategy received at runtime, validated against the canonical engine schema (ENGINE.md Section 20). Recognised parameters are passed verbatim into POST /backtests to reproduce the run.

Engine Parameters
YAML

Parameter	Value	Meaning
`assumed_spread_bps`	`0`	Spread (basis points) added to taker fills on top of the candle price.
`buyPercentage`	`0.1`	Buy-trigger threshold as a fraction (e.g. `0.1` = -0.1% from last reference price).
`buySplits`	`2`	Number of price levels in the buy-ladder (DCA depth).
`buyVolumes`	`[50,50]`	Per-split sizing weights (sum ~ 100). Distributes `investmentPerBuy x buySplits` across the ladder.
`canBuy`	`true`	Master switch - disables all buy-side logic when false.
`canBuyDown`	`false`	Allow re-entries below the last buy price.
`canBuyUp`	`true`	Allow re-entries above the last buy price (true) or only below (false).
`canSell`	`true`	Master switch - disables all sell-side logic when false.
`dontBuyBelowQuoteAssetBalance`	`1`	Refuse to open new buys if free quote drops below this absolute USDT amount.
`fees_in_quote`	`true`	If true, fees are deducted from the quote (USDT) leg of every fill.
`intrabar_mode`	`OLHC`	Intra-bar fill model (`OLHC`, `OHLC`, …) - see ENGINE.md Section 4.
`investmentPerBuy`	`3`	Notional invested per buy event, in quote (USDT).
`investmentPerFreeQuotePercent`	`0.01`	When `investmentPercentMode = true`: fraction of free quote balance to commit per buy.
`investmentPercentMode`	`false`	If true, sizing is taken as a fraction of free quote balance instead of fixed USDT.
`maker_fee_bps`	`7.5`	Maker fee in basis points (e.g. `7.5` = 0.075%).
`minInvestmentPerQuote`	`3`	Hard floor on per-buy notional, regardless of percent-mode math.
`minNotional`	`5`	Exchange minimum notional per order (USDT).
`order_latency_seconds`	`2`	Latency injected between signal time and order placement.
`sellActivateDistancePercentage`	`0.1`	Distance from buy price (%) at which a TSL becomes armed.
`sellCancelDistancePercentage`	`1`	Distance (%) at which an unfilled sell order is cancelled and re-priced.
`sellPercentages`	`[0.25,0.3]`	Take-profit ladder, each value is the per-tier profit target as a fraction.
`startBal`	`10000`	Initial portfolio value in the quote currency (USDT).
`stepSize`	`1`	Exchange size step (base asset).
`stopLoss`	`false`	Hard stop-loss enabled flag.
`stopLossPercentage`	`5`	Hard stop-loss distance from entry as a percent (`5.0` = -5%).
`taker_fee_bps`	`7.5`	Taker fee in basis points.
`tickSize`	`0.00001`	Exchange price tick (quote currency).
`trailingStopLossPercentages`	`[0,0]`	Per-tier trailing-SL distances. Zero entries disable TSL on that tier.
`triggerCoolDown`	`1`	Minimum bars/ticks between two consecutive buys on the same level.

to: "2025-12-31 23:59:59"
from: "2025-01-01 00:00:01"
canBuy: true
symbol: KGSTUSDT
canSell: true
canBuyUp: true
startBal: 10000
stepSize: 1
stopLoss: false
tickSize: 0.00001
buySplits: 2
buyVolumes:
  - 50
  - 50
canBuyDown: false
minNotional: 5
buyPercentage: 0.1
fees_in_quote: true
intrabar_mode: OLHC
maker_fee_bps: 7.5
taker_fee_bps: 7.5
sellPercentages:
  - 0.25
  - 0.3
triggerCoolDown: 1
investmentPerBuy: 3
assumed_spread_bps: 0
stopLossPercentage: 5
investmentPercentMode: false
minInvestmentPerQuote: 3
order_latency_seconds: 2
trailingStopLossPercentages:
  - 0
  - 0
sellCancelDistancePercentage: 1
dontBuyBelowQuoteAssetBalance: 1
investmentPerFreeQuotePercent: 0.01
sellActivateDistancePercentage: 0.1

Strategy Logic

This section explains what the strategy actually does - the rules behind the parameters in Strategy Configuration. Without it the report would be a black box: numbers without semantics. We treat its absence as a defect, not a feature.

Black-box notice: this export does not include a machine-readable description of the strategy rules. The numeric results are still fully reproducible from the parameters in Strategy Configuration + the raw API attachments below, but the semantics of those parameters live in the engine source. Pass a strategyLogic object to buildVerifiableMdx (or wire up getModes() so the exporter can derive a sketch) to remove this notice.

Source unavailable in this export. Fetch GET /modes and select the entry whose filename == "5LowMoney.json" to inspect the public rule fields, or consult the engine source for the executable logic.

Engine Specification

The execution engine is shared across every backtest on this site. Its static semantics - TP-vs-SL ordering inside an OLHC bar, TSL splits bypassing nominal TP, JS-legacy boolean parsing, Binance hard caps, fee model, equity sampling - are documented once in the canonical Engine Specification and pinned per-run via the engine_version field in this document’s frontmatter (see also the Data Source Metadata section).

Engine Specification

Canonical, versioned spec covering the bar-loop, order types, intra-bar fill rules, gap handling, fees, position sizing, risk management, multi-entry cascade, sell-time curves, portfolio accounting, determinism guarantees and the full configuration schema (Section 20).

Why this is a link, not an inline copy: the spec is identical for every backtest - embedding ~700 lines into each export would bloat every report 5-10x without adding per-run information. The single source of truth lives at uncoded.ch/docs/engine; this report only pins which revision applied (engine_version in the frontmatter).

Data Source Metadata

Inputs the engine consumed for this run. Anything marked not provided is explicitly missing rather than silently omitted - pass the corresponding field via buildVerifiableMdx({ dataSource: ... }) to fill it in. The engine spec describes deterministic execution semantics (segment order, fill rules, fee classification) that cannot be reverse-engineered from trades alone.

Field	Value	Source
Market-data provider	`Binance Spot`	caller `DataSourceInput.provider`
Exchange / venue	`binance`	caller `DataSourceInput.exchange`
Symbol	`KGSTUSDT`	`GET /backtests/{id}` -> `$.symbol`
Candle interval	`1m`	platform invariant - all backtests run on 1-minute OHLCV candles
First candle (UTC)	`2025-01-01 00:00:01`	`GET /backtests/{id}` -> `$.config.from`
Last candle (UTC)	`2025-12-31 23:59:59`	`GET /backtests/{id}` -> `$.config.to`
Timezone	`UTC`	default assumption (`UTC`)
Engine version	`uncoded-engine (FastAPI backend)`	caller `DataSourceInput.engineVersion`
Engine spec version	`1.1`	caller `DataSourceInput.engineSpecVersion`
Engine spec document	`https://uncoded.ch/docs/engine`	caller `DataSourceInput.engineSpecPath`

Full data-source coverage (10/10 fields populated).

Equity Curve

Data source - GET /backtests/{id}/equity * Fields used: timestamp, total_value_exit_net, total_value_mid, total_value

Portfolio value evolution from 10,000.00 USDT to 10,000.00 USDT across 8 data points.

    10,000 |                                                            
           |                                                            
           |                                                            
           |                                                            
           |                                                            
           |                                                            
           |                                                            
           |                                                            
           |                                                            
    10,000 |############################################################
           +------------------------------------------------------------
           start                                                   end

Risk & Quality Metrics

Data source - GET /backtests/{id}/equity * Fields used: timestamp, total_value_exit_net, total_value_mid, total_value, base_asset_bal (for time-in-market)

Drawdown, CAGR, Sharpe, Sortino & Volatility are computed client-side from the equity series - not returned by the API directly.

Derived from 8 equity samples across 7.0 days. Sharpe & Sortino are annualized using daily-resampled returns (rf = 0).

Max Drawdown

-0.00% (-0.00 USDT)

CAGR

0.00%

Volatility (ann.)

0.00%

Sharpe Ratio

Sortino Ratio

Time in Market

0.0%

Drawdown Detail

Field	Value
Peak	- USDT @ -
Trough	- USDT @ -
Drawdown Duration	-
Recovery	not yet recovered within window
All-time Peak	10,000.00 USDT

Final Portfolio Allocation

Data source - GET /backtests/{id}/equity * Fields used: total_value_exit_net, quote_asset_bal, base_asset_bal, base_value_exit_net, base_value_mid, unrealized_pnl_exit_net

Snapshot at backtest end (2026-04-19 16:39:04 UTC):

Asset	Quantity	Value (USDT)	Allocation
USDT (Cash)	10,000.00	10,000.00	100.0%
KGST	0.00000000	0.00	0.0%
Total	-	10,000.00	100.0%

Unrealized P&L on remaining position: 0.00 USDT. The “Other” row, when present, is dominated by these open positions held outside the cash/base buckets.

Charts Catalogue

Data source - GET /backtests/{id} + /equity + /trades * Fields used: every chart from the live <AnalyticsCharts> UI, with the exact transform + API fields it consumes

Below is the complete set of analytical charts shown in the backtester UI, regrouped into the same five tabs. Each card lists what it shows, how to read it, why it matters, the API fields + transform that produce it, and a down-sampled JSON preview of the underlying series so you can re-render the visualisation in any tool (Notion, Observable, a notebook, …) without calling the API again.

JSON previews are intentionally down-sampled (<= 60 points for line/area series, full bins for histograms). For the full series, hit the corresponding REST endpoint with your X-API-Key.

Equity & Balance
Trade Analysis
Risk & Recovery
Deep Dive
Advanced

Drawdown

Data source - GET /backtests/{id}/equity * Fields used: timestamp, total_value_exit_net * Transform: computeDrawdown(equity)

What it shows. Percentage decline of the portfolio from its running all-time peak. Always <= 0%.How to read it. Each point is the relative drop from the highest equity value seen so far. The deepest valley is the maximum drawdown - the worst peak-to-trough loss any investor would have lived through.Why it matters. The single most important risk metric. A high return with a 60% drawdown is psychologically unsurvivable for most live traders.

Series contains 8 points but every numeric value is zero - likely a missing equity column (see ENGINE.md Section 13.1). Skipping the JSON payload to avoid suggesting measured data exists.

Unrealized PnL

Data source - GET /backtests/{id}/equity * Fields used: timestamp, unrealized_pnl_exit_net * Transform: equity.map(p => ({ pnl: p.unrealized_pnl_exit_net }))

What it shows. Mark-to-market profit/loss of currently open positions, sampled along the backtest timeline.How to read it. Above zero => open positions are in profit; below zero => positions are underwater. Spikes show how much paper-PnL the strategy carries before realising it.Why it matters. Reveals the gap between realised (closed-trade) profit and the rollercoaster the strategy actually rides. Large negative excursions indicate the bot held losers.

Series contains 8 points but every numeric value is zero - likely a missing equity column (see ENGINE.md Section 13.1). Skipping the JSON payload to avoid suggesting measured data exists.

Balance Composition (Cash vs. Coin)

Data source - GET /backtests/{id}/equity * Fields used: quote_asset_bal, base_value_exit_net, total_value_exit_net * Transform: stack(quote, base, total)

What it shows. Stacked area showing how the portfolio value splits between quote (cash) and base (coin held).How to read it. Cash floor stacks first, coin value on top - the top of the stack equals total equity. Wider coin bands => heavier in-market exposure.Why it matters. Lets you see whether outperformance came from holding coin during a rally or from disciplined cash management.Insights (auto-derived from total).

Stat	Value
Peak Total Equity	10,000.00 USDT @ 2025-12-24 23:59:00 UTC
Trough Total Equity	10,000.00 USDT @ 2025-12-24 23:59:00 UTC
Mean	10,000.00 USDT
Std Dev	0.0000 USDT
Last	10,000.00 USDT
Points	8
Sum	80,000.00 USDT
Across 8 points the series ranged from 10,000.00 USDT (2025-12-24 23:59:00 UTC) to 10,000.00 USDT (2025-12-24 23:59:00 UTC), averaging 10,000.00 USDT. 100% of points were positive, 0% negative. The most recent value is 10,000.00 USDT.
Full series - 8 points.

Balance Composition (Cash vs. Coin)

[{"timestamp":"2025-12-24T23:59:00+00:00","quote":10000,"base":0,"total":10000},{"timestamp":"2025-12-25T23:59:00+00:00","quote":10000,"base":0,"total":10000},{"timestamp":"2025-12-26T23:59:00+00:00","quote":10000,"base":0,"total":10000},{"timestamp":"2025-12-27T23:59:00+00:00","quote":10000,"base":0,"total":10000},{"timestamp":"2025-12-28T23:59:00+00:00","quote":10000,"base":0,"total":10000},{"timestamp":"2025-12-29T23:59:00+00:00","quote":10000,"base":0,"total":10000},{"timestamp":"2025-12-30T23:59:00+00:00","quote":10000,"base":0,"total":10000},{"timestamp":"2025-12-31T23:59:00+00:00","quote":10000,"base":0,"total":10000}]

Base Exposure (% of Portfolio)

Data source - GET /backtests/{id}/equity * Fields used: base_value_exit_net, quote_asset_bal, total_value_exit_net * Transform: baseExposure(equity)

What it shows. Share of total portfolio value invested in the base coin at each sample.How to read it. 0% = fully in cash, 100% = fully invested. Areas above ~70% mean the strategy was strongly directional at that moment.Why it matters. Quantifies risk-on / risk-off behaviour. Low average exposure with strong returns hints at high capital efficiency.

Series contains 8 points but every numeric value is zero - likely a missing equity column (see ENGINE.md Section 13.1). Skipping the JSON payload to avoid suggesting measured data exists.

Daily Change

Data source - GET /backtests/{id}/equity * Fields used: timestamp, total_value_exit_net * Transform: dailyDelta(equity)

What it shows. First-difference of total_value_exit_net between consecutive equity samples (typically daily).How to read it. Green bars are gain days, red bars are loss days. A long stretch of red bars indicates a sustained drawdown, not just a single bad day.Why it matters. Shows whether returns are consistent or driven by a few jackpot days - important for compounding and for sizing live capital.

Series contains 7 points but every numeric value is zero - likely a missing equity column (see ENGINE.md Section 13.1). Skipping the JSON payload to avoid suggesting measured data exists.

Monthly Returns

Data source - GET /backtests/{id}/equity * Fields used: timestamp, total_value_exit_net * Transform: monthlyReturns(equity)

What it shows. Calendar-month percentage return computed from the first vs. last equity value of each month.How to read it. Green bars = profitable months, red bars = losing months. Look for clusters of red - they often map to specific market regimes (e.g. crypto bear quarters).Why it matters. Calendar-month returns are the standard reporting unit for traders and funds; they make like-for-like comparison with HODL trivial.

Series contains 1 points but every numeric value is zero - likely a missing equity column (see ENGINE.md Section 13.1). Skipping the JSON payload to avoid suggesting measured data exists.

Cumulative Trade Profit

Data source - GET /backtests/{id}/trades * Fields used: sell_time, profit * Transform: cumulativeProfit(trades)

What it shows. Running sum of realised per-trade profit, ordered by sell time.How to read it. Steep upward slope => winning streak. Plateaus => many neutral or breakeven trades. Down-slopes => losses dominate.Why it matters. Distinguishes ‘one big win + many losers’ (lottery) from ‘many small wins’ (edge). Smooth, monotonically rising curves are the dream.

No data available for this chart in the current run.

Daily Trade Profit

Data source - GET /backtests/{id}/trades * Fields used: sell_time, profit * Transform: dailyTradeProfit(trades)

What it shows. Aggregated realised profit per calendar day across all trades.How to read it. Tall green bars are blockbuster days, red bars are pain days. Variance here drives the equity volatility above.Why it matters. Helps spot regime-dependence - e.g. all profit concentrated on Mondays, or all losses during weekend pumps.

No data available for this chart in the current run.

Trades per Day

Data source - GET /backtests/{id}/trades * Fields used: sell_time * Transform: tradesPerDay(trades)

What it shows. How many trades closed on each calendar day.How to read it. High bars = busy days (often during high volatility). Empty days = strategy sat on its hands.Why it matters. Sanity check on activity. Strategies that fire 200+ trades/day will be fee-bled in live; <1 trade/week may be too sparse to trust statistically.

No data available for this chart in the current run.

Cumulative Fees

Data source - GET /backtests/{id}/trades * Fields used: sell_time, buy_fee_in_quote, sell_fee_in_quote * Transform: cumulativeFees(trades)

What it shows. Running sum of buy + sell fees across all trades, in quote currency.How to read it. A nearly-linear curve confirms fees scale with trade count. Steep slopes warn of an over-trading strategy.Why it matters. Compare the final value to total realised profit - if fees >= 50% of gross profit, the strategy is paying the exchange more than the trader.

No data available for this chart in the current run.

Profit Distribution (%)

Data source - GET /backtests/{id}/trades * Fields used: profit_percentage * Transform: profitDistribution(trades, 30)

What it shows. Histogram of per-trade percentage returns, binned across the observed range.How to read it. A long left-tail (deep losses) with a short right-tail screams ‘pick up pennies in front of a steamroller’. Tight, right-shifted bins are healthy.Why it matters. Distribution shape matters more than the average - payoff asymmetry decides whether the strategy survives black-swan markets.

No data available for this chart in the current run.

Rolling Win Rate (50 Trades)

Data source - GET /backtests/{id}/trades * Fields used: profit * Transform: rollingWinRate(trades, 50)

What it shows. Percentage of profitable trades within a sliding window of the last 50 closed trades.How to read it. Above 50% line => recent edge holds. Sustained dips below => regime change or strategy decay.Why it matters. Win rate alone is meaningless (you can have 90% wins and still lose money). Rolling win rate spots when the edge breaks over time.

No data available for this chart in the current run.

Gross vs. Net PnL (Fee Impact)

Data source - GET /backtests/{id}/trades * Fields used: sell_time, profit, buy_fee_in_quote, sell_fee_in_quote * Transform: grossVsNetPnL(trades)

What it shows. Two cumulative-profit lines: gross (before subtracting fees) vs. net (the actual realised profit).How to read it. The vertical gap between gross and net is exactly what the exchange earned. Wider gaps => heavier fee drag.Why it matters. Quantifies the fee tax on edge. Useful when comparing fee-tier upgrades or maker-vs-taker variants.

No data available for this chart in the current run.

Rolling Sharpe Ratio (30d / 90d)

Data source - GET /backtests/{id}/equity * Fields used: timestamp, total_value_exit_net * Transform: rollingSharpe(equity, 30) + rollingSharpe(equity, 90)

What it shows. Annualised risk-adjusted return computed over rolling 30-day and 90-day windows.How to read it. Above 1 = solid, above 2 = excellent, below 0 = losing money on risk-adjusted basis. Compare 30d vs 90d to see short vs medium-term consistency.Why it matters. A flat-to-rising rolling Sharpe is the gold standard for production-ready strategies; a collapsing Sharpe predicts upcoming drawdowns.

No data available for this chart in the current run.

Drawdown Recovery Episodes

Data source - GET /backtests/{id}/equity * Fields used: timestamp, total_value_exit_net * Transform: drawdownRecoveryEpisodes(equity)

What it shows. Each point is one drawdown episode: x-axis = duration in days, y-axis = depth in %.How to read it. Top-left = quick shallow dips (good). Bottom-right = long deep underwater periods (bad). The single worst point dominates investor PTSD.Why it matters. Investors care about how long they sat underwater as much as how deep. This chart surfaces both at once.

No data available for this chart in the current run.

Consecutive Win/Loss Streaks

Data source - GET /backtests/{id}/trades * Fields used: sell_time, profit * Transform: consecutiveStreaks(trades)

What it shows. Length of every uninterrupted run of wins (green) and losses (red) in chronological order.How to read it. Long red bars are the painful streaks; long green bars are the lucky ones. The longest red streak sets the realistic position-sizing limit.Why it matters. Behaviour during a 10-trade losing streak determines if a real trader would still be running the bot - most are not.

No data available for this chart in the current run.

Capital Utilization (% Invested)

Data source - GET /backtests/{id}/equity * Fields used: base_value_exit_net, total_value_exit_net * Transform: baseExposure(equity)

What it shows. Same series as Base Exposure, re-framed as ‘how much working capital was actually deployed’.How to read it. Average level = average capital efficiency. 30% average means the strategy could in theory run 3x the notional with the same cash.Why it matters. Two strategies with identical returns are not equal - the one using less capital is far more attractive for portfolio composition.

Series contains 8 points but every numeric value is zero - likely a missing equity column (see ENGINE.md Section 13.1). Skipping the JSON payload to avoid suggesting measured data exists.

Price Chart with Buy/Sell Markers

Data source - GET /backtests/{id}/trades * Fields used: buy_time, buy_price, sell_time, sell_price * Transform: priceWithMarkers(trades)

What it shows. Reconstructed price line of the traded asset with green dots for buys and red dots for sells.How to read it. Buys clustered near local lows + sells near highs => good market timing. Buys near local highs => classic FOMO behaviour.Why it matters. The most intuitive sanity check on whether the strategy is actually buying low and selling high vs. simply riding momentum.

No data available for this chart in the current run.

Total markers: 0 buys, 0 sells (UI caps each at 500 dots).

Trade Size Distribution (Notional)

Data source - GET /backtests/{id}/trades * Fields used: buy_price, buy_quantity * Transform: tradeSizeDistribution(trades, 25)

What it shows. Histogram of per-trade notional value (buy_price x buy_quantity) in quote currency.How to read it. A tight peak => uniform sizing. A long right-tail => a few oversized positions that dominate PnL and risk.Why it matters. Position-size variance is a hidden risk factor - strategies that ape into one mega-trade are not as repeatable as their headline numbers suggest.

No data available for this chart in the current run.

Return Distribution by Fill Type

Data source - GET /backtests/{id}/trades * Fields used: fill_type, profit_percentage * Transform: returnByFillType(trades)

What it shows. Stacked histogram showing how TP (take-profit), SL (stop-loss) and TSL (trailing stop-loss) fills are distributed across return bins.How to read it. Healthy strategies have TP fills bunched on the right (positive returns) and SL/TSL fills bunched on the left. Overlap between them indicates fuzzy exit logic.Why it matters. Confirms each exit mechanism does its job. If SL fills land in positive territory, the stop is probably too tight; if TP fills land in red, the order routing is broken.

No data available for this chart in the current run.

Monthly Equity Comparison (YoY)

Data source - GET /backtests/{id}/equity * Fields used: timestamp, total_value_exit_net * Transform: monthlyEquityYoY(equity)

What it shows. Equity rebased to 100 at the start of each calendar year, plotted month-by-month so years overlay.How to read it. Lines that consistently end above 100 => profitable in every plotted year. Crossover with the 100 reference line tells you when the year flipped from green to red.Why it matters. Year-over-year overlay is the fastest visual test for regime stability - strategies that worked only in 2021 will stand out clearly.Full series - 12 points.

Monthly Equity Comparison (YoY)

[
  {
    "month": "Jan"
  },
  {
    "month": "Feb"
  },
  {
    "month": "Mar"
  },
  {
    "month": "Apr"
  },
  {
    "month": "May"
  },
  {
    "month": "Jun"
  },
  {
    "month": "Jul"
  },
  {
    "month": "Aug"
  },
  {
    "month": "Sep"
  },
  {
    "month": "Oct"
  },
  {
    "month": "Nov"
  },
  {
    "2025": 100,
    "month": "Dec"
  }
]

Profit by Weekday

Data source - GET /backtests/{id}/trades * Fields used: sell_time, profit * Transform: profitByWeekday(trades)

What it shows. Sum of realised profit aggregated by ISO weekday (Mon-Sun).How to read it. Bars above zero => winning days of the week, bars below => losing days. Crypto often shows distinct weekend behaviour.Why it matters. Surfaces calendar effects that a strategy may inadvertently exploit (or be exposed to). Useful for time-based filters in production.

Series contains 7 points but every numeric value is zero - likely a missing equity column (see ENGINE.md Section 13.1). Skipping the JSON payload to avoid suggesting measured data exists.

Profit by Hour (UTC)

Data source - GET /backtests/{id}/trades * Fields used: sell_time, profit * Transform: profitByHour(trades)

What it shows. Sum of realised profit aggregated by hour-of-day (UTC), 0-23.How to read it. Clusters around US/EU/Asia trading sessions reveal which liquidity window the strategy actually monetises.Why it matters. Lets you build a time-of-day filter or schedule the live bot to only run during profitable hours, cutting fees and infra cost.

Series contains 24 points but every numeric value is zero - likely a missing equity column (see ENGINE.md Section 13.1). Skipping the JSON payload to avoid suggesting measured data exists.

Profit vs. Hold Time

Data source - GET /backtests/{id}/trades * Fields used: buy_time, sell_time, profit_percentage * Transform: holdTimes(trades)

What it shows. Scatter plot: x = trade hold duration in hours, y = realised return %.How to read it. Concentration in the upper-left (short hold + positive return) is ideal - fast turnover with edge. Lower-right (long hold + loss) means the strategy bag-holds losers.Why it matters. Tests whether time-in-market correlates with profitability. Strategies with no relationship are usually noise-driven.

No data available for this chart in the current run.

Fill Type Breakdown

Data source - GET /backtests/{id}/trades * Fields used: fill_type * Transform: computeKPIs(equity, trades).fillTypes

What it shows. Counts of how many trades closed via TP (take-profit), SL (stop-loss) or TSL (trailing stop-loss).How to read it. TP-dominant => targets do most of the work. SL-dominant => the strategy bleeds via stops. TSL-dominant => relies heavily on trend-following.Why it matters. Tells you how profit was made, not just how much. Two strategies with the same return but different fill mixes have very different live behaviour.

Series contains 3 points but every numeric value is zero - likely a missing equity column (see ENGINE.md Section 13.1). Skipping the JSON payload to avoid suggesting measured data exists.

Machine-Readable Facts

This section is optimized for LLM/RAG consumption. Every metric appears as both a flat key/value row and as canonical JSON so a model can quote exact values without re-deriving them. The JSON below is the exact object whose SHA-256 is published as facts_sha256 in the frontmatter - re-hash it to verify.

JSON
Flat Table

facts.json

{
  "backtest_id": "1522e1a0-8523-4e5e-aa9d-a92c68269e5b",
  "symbol": "KGSTUSDT",
  "strategy": "5LowMoney.json",
  "strategy_label": "LowMoney",
  "status": "completed",
  "period_from": "2025-01-01",
  "period_to": "2025-12-31",
  "duration_days": 7,
  "start_balance_usdt": 10000,
  "final_value_usdt": 10000,
  "return_pct": 0,
  "total_profit_usdt": 0,
  "avg_profit_per_trade_usdt": null,
  "fulfilled_trades": 0,
  "active_orders": null,
  "win_rate_pct": null,
  "best_trade_usdt": null,
  "worst_trade_usdt": null,
  "trades_per_month": null,
  "max_drawdown_pct": 0,
  "max_drawdown_abs_usdt": 0,
  "drawdown_duration_days": null,
  "recovery_days": null,
  "cagr_pct": 0,
  "volatility_annualized_pct": 0,
  "sharpe_annualized": null,
  "sortino_annualized": null,
  "time_in_market_pct": 0,
  "final_cash_usdt": 10000,
  "final_base_value_usdt": null,
  "final_unrealized_pnl_usdt": 0,
  "median_hold_hours": null,
  "avg_hold_hours": null,
  "buyhold_return_pct": null,
  "outperformance_vs_buyhold_pp": null
}

Key	Value
`backtest_id`	`1522e1a0-8523-4e5e-aa9d-a92c68269e5b`
`symbol`	`KGSTUSDT`
`strategy`	`5LowMoney.json`
`strategy_label`	`LowMoney`
`status`	`completed`
`period_from`	`2025-01-01`
`period_to`	`2025-12-31`
`duration_days`	7
`start_balance_usdt`	10000
`final_value_usdt`	10000
`return_pct`	0
`total_profit_usdt`	0
`avg_profit_per_trade_usdt`	null
`fulfilled_trades`	0
`active_orders`	null
`win_rate_pct`	null
`best_trade_usdt`	null
`worst_trade_usdt`	null
`trades_per_month`	null
`max_drawdown_pct`	0
`max_drawdown_abs_usdt`	0
`drawdown_duration_days`	null
`recovery_days`	null
`cagr_pct`	0
`volatility_annualized_pct`	0
`sharpe_annualized`	null
`sortino_annualized`	null
`time_in_market_pct`	0
`final_cash_usdt`	10000
`final_base_value_usdt`	null
`final_unrealized_pnl_usdt`	0
`median_hold_hours`	null
`avg_hold_hours`	null
`buyhold_return_pct`	null
`outperformance_vs_buyhold_pp`	null

Metric Provenance Index

For every headline metric in this report, this table answers three questions: where did the value come from, what JSON field, and what transform (if any) was applied. Use it to audit any number - or to teach an LLM to cite values verbatim.

Metric	Source	JSON path	Transform	Value in this report
Symbol	`GET /backtests/{id}`	`$.symbol`	direct API value	`KGSTUSDT`
Mode	`GET /backtests/{id}`	`$.mode_name`	direct API value	`5LowMoney.json`
Status	`GET /backtests/{id}`	`$.status`	direct API value	`completed`
Period start	`GET /backtests/{id}`	`$.config.from`	direct API value	`2025-01-01 00:00:01`
Period end	`GET /backtests/{id}`	`$.config.to`	direct API value	`2025-12-31 23:59:59`
Start balance	`GET /backtests/{id}`	`$.start_balance`	direct API value	10,000.00 USDT
Final value	`GET /backtests/{id}`	`$.final_value`	direct API value	10,000.00 USDT
Return %	`GET /backtests/{id}`	`$.return_pct`	direct API value (cross-check: `(final_value/start_balance - 1) * 100`)	0.00%
Total profit	`GET /backtests/{id}`	`$.total_profit`	direct API value (cross-check: `Sum trades[].profit`)	0.00 USDT
Win rate %	`GET /backtests/{id}`	`$.win_rate`	direct API value (cross-check: `100 * count(trades[].profit > 0) / count(trades)`)	-
Trades count	`GET /backtests/{id}`	`$.fulfilled_trades`	direct API value (cross-check: `count(trades)`)	0
Best trade	`GET /backtests/{id}`	`$.max_profit`	direct API value (cross-check: `max(trades[].profit)`)	- USDT
Worst trade	`GET /backtests/{id}`	`$.min_profit`	direct API value (cross-check: `min(trades[].profit)`)	- USDT
Avg profit / trade	`GET /backtests/{id}`	`$.avg_profit`	direct API value	- USDT
Trades / month	`derived`	`n/a`	`fulfilled_trades / (durationDays / 30.4375)`	-
Max drawdown %	`GET /backtests/{id}/equity`	`$[].total_value_`	`maxDrawdown(equity)` - running peak vs. trough	-0.00%
Max drawdown abs	`GET /backtests/{id}/equity`	`$[].total_value_`	`maxDrawdown(equity).abs`	-0.00 USDT
CAGR %	`GET /backtests/{id}/equity`	`$[].timestamp, $[].total_value_*`	`(final/start)^(365.25/days) - 1`	0.00%
Volatility (ann.) %	`GET /backtests/{id}/equity`	`$[].timestamp, $[].total_value_*`	`std(daily_returns) * sqrt(365)`	0.00%
Sharpe ratio (ann.)	`GET /backtests/{id}/equity`	`$[].timestamp, $[].total_value_*`	`mean(daily_returns) / std(daily_returns) * sqrt(365)` (rf=0)	-
Sortino ratio (ann.)	`GET /backtests/{id}/equity`	`$[].timestamp, $[].total_value_*`	`mean(daily_returns) / std(downside_returns) * sqrt(365)` (rf=0)	-
Time in market %	`GET /backtests/{id}/equity`	`$[*].base_asset_bal`	`count(samples where base_asset_bal>0) / count(samples) * 100`	0.0%

Any number in the rest of this document that doesn’t appear here is derived from the rows above via a transform documented inline at its point of use.

Raw API Attachments

These blocks are the unmodified API responses that produced every metric in this report. They are large by design - collapse them with the accordions below if you’re reading the doc as prose. Verify their integrity via the fingerprints in the Data Integrity chunk.

GET /backtests/1522e1a0-8523-4e5e-aa9d-a92c68269e5b - backtest summary (verbatim)

backtest.json

{
  "id": "1522e1a0-8523-4e5e-aa9d-a92c68269e5b",
  "status": "completed",
  "error_message": null,
  "created_at": "2026-04-19T12:41:49.590578Z",
  "started_at": "2026-04-19T16:37:10.016632Z",
  "completed_at": "2026-04-19T16:39:04.516471Z",
  "mode_name": "5LowMoney.json",
  "symbol": "KGSTUSDT",
  "data_file": "",
  "start_balance": 10000,
  "final_value": 10000,
  "return_pct": 0,
  "total_profit": 0,
  "fulfilled_trades": 0,
  "active_orders": null,
  "win_rate": null,
  "avg_profit": null,
  "max_profit": null,
  "min_profit": null,
  "elapsed_sec": 1.72,
  "max_drawdown": 0,
  "profit_factor": null,
  "sharpe_ratio": null,
  "total_fees": null,
  "avg_hold_time_hours": null,
  "tp_count": 0,
  "sl_count": 0,
  "tsl_count": 0,
  "start_price": 0.01142,
  "end_price": 0.01138,
  "gross_profit_quote": null,
  "gross_loss_quote": null,
  "wins": 0,
  "losses": 0,
  "breakeven": 0,
  "consecutive_wins_max": 0,
  "consecutive_losses_max": 0,
  "holding_minutes_p50": null,
  "holding_minutes_p95": null,
  "holding_minutes_max": null,
  "description": "KGSTUSDT | 5LowMoney.json | 2025-01-01 - 2025-12-31 | +0.00%",
  "summary_text": "Backtest KGSTUSDT (Mode: 5LowMoney.json)\nPeriod: 2025-01-01 00:00:01 to 2025-12-31 23:59:59\nStarting balance: 10,000.00 USDT\nFinal value: 10,000.00 USDT\nP&L: +0.00 USDT (+0.00%)\nResult: PROFIT\nCompleted trades: 0\nOpen orders at end: 0\n\nStrategy parameters:\n  Buy trigger: -0.1% from last buy\n  Buy splits: 2\n  Sell targets: [0.25, 0.3]\n  Investment per buy: 3.0 USDT\n  Fees: maker 7.5 bps / taker 7.5 bps\n\nElapsed: 1.7s",
  "share_token": null,
  "config_hash": "5f722b759a7117555c800e16351da00258672930b2b371415bc78f4a34e4f9f8",
  "config": {
    "to": "2025-12-31 23:59:59",
    "from": "2025-01-01 00:00:01",
    "canBuy": true,
    "symbol": "KGSTUSDT",
    "canSell": true,
    "canBuyUp": true,
    "startBal": 10000,
    "stepSize": 1,
    "stopLoss": false,
    "tickSize": 0.00001,
    "buySplits": 2,
    "buyVolumes": [
      50,
      50
    ],
    "canBuyDown": false,
    "minNotional": 5,
    "buyPercentage": 0.1,
    "fees_in_quote": true,
    "intrabar_mode": "OLHC",
    "maker_fee_bps": 7.5,
    "taker_fee_bps": 7.5,
    "sellPercentages": [
      0.25,
      0.3
    ],
    "triggerCoolDown": 1,
    "investmentPerBuy": 3,
    "assumed_spread_bps": 0,
    "stopLossPercentage": 5,
    "investmentPercentMode": false,
    "minInvestmentPerQuote": 3,
    "order_latency_seconds": 2,
    "trailingStopLossPercentages": [
      0,
      0
    ],
    "sellCancelDistancePercentage": 1,
    "dontBuyBelowQuoteAssetBalance": 1,
    "investmentPerFreeQuotePercent": 0.01,
    "sellActivateDistancePercentage": 0.1
  },
  "is_duplicate": false,
  "compact": false
}

GET /backtests/1522e1a0-8523-4e5e-aa9d-a92c68269e5b/equity - equity series (verbatim, 8 points)

equity.json

[
  {
    "timestamp": "2025-12-24T23:59:00+00:00",
    "base_asset_bal": 0,
    "quote_asset_bal": 10000,
    "total_value_mid": 10000,
    "total_value_exit_net": 10000,
    "total_value": 10000,
    "base_cost_quote": 0,
    "unrealized_pnl_exit_net": 0
  },
  {
    "timestamp": "2025-12-25T23:59:00+00:00",
    "base_asset_bal": 0,
    "quote_asset_bal": 10000,
    "total_value_mid": 10000,
    "total_value_exit_net": 10000,
    "total_value": 10000,
    "base_cost_quote": 0,
    "unrealized_pnl_exit_net": 0
  },
  {
    "timestamp": "2025-12-26T23:59:00+00:00",
    "base_asset_bal": 0,
    "quote_asset_bal": 10000,
    "total_value_mid": 10000,
    "total_value_exit_net": 10000,
    "total_value": 10000,
    "base_cost_quote": 0,
    "unrealized_pnl_exit_net": 0
  },
  {
    "timestamp": "2025-12-27T23:59:00+00:00",
    "base_asset_bal": 0,
    "quote_asset_bal": 10000,
    "total_value_mid": 10000,
    "total_value_exit_net": 10000,
    "total_value": 10000,
    "base_cost_quote": 0,
    "unrealized_pnl_exit_net": 0
  },
  {
    "timestamp": "2025-12-28T23:59:00+00:00",
    "base_asset_bal": 0,
    "quote_asset_bal": 10000,
    "total_value_mid": 10000,
    "total_value_exit_net": 10000,
    "total_value": 10000,
    "base_cost_quote": 0,
    "unrealized_pnl_exit_net": 0
  },
  {
    "timestamp": "2025-12-29T23:59:00+00:00",
    "base_asset_bal": 0,
    "quote_asset_bal": 10000,
    "total_value_mid": 10000,
    "total_value_exit_net": 10000,
    "total_value": 10000,
    "base_cost_quote": 0,
    "unrealized_pnl_exit_net": 0
  },
  {
    "timestamp": "2025-12-30T23:59:00+00:00",
    "base_asset_bal": 0,
    "quote_asset_bal": 10000,
    "total_value_mid": 10000,
    "total_value_exit_net": 10000,
    "total_value": 10000,
    "base_cost_quote": 0,
    "unrealized_pnl_exit_net": 0
  },
  {
    "timestamp": "2025-12-31T23:59:00+00:00",
    "base_asset_bal": 0,
    "quote_asset_bal": 10000,
    "total_value_mid": 10000,
    "total_value_exit_net": 10000,
    "total_value": 10000,
    "base_cost_quote": 0,
    "unrealized_pnl_exit_net": 0
  }
]

Verbatim trades.json payload is intentionally not embedded in this report (deprecated). The full trade ledger is attached below as RFC 4180 CSV (with a SHA-256 fingerprint) - and is also fetchable from GET /backtests/1522e1a0-8523-4e5e-aa9d-a92c68269e5b/trades.

Full trade list as RFC 4180 CSV (0 rows)

No trades to attach.

Frequently Asked Questions

Deterministic Q&A - every question is always present so this section can be sliced into stable RAG chunks. Missing API fields render as _null_; metrics that can’t be derived locally render as “not available”.

What strategy was tested and on which trading pair?

The LowMoney strategy was tested on KGSTUSDT over 2025-01-01 to 2025-12-31._{Source: bt.mode_name, bt.symbol, bt.config.from, bt.config.to}

What is the current status of this backtest?

Completed. Final metrics are available below._{Source: bt.status, bt.error_message}

What was the total return?

0.00% - turning 10,000.00 USDT into 10,000.00 USDT (net profit 0.00 USDT)._{Source: bt.return_pct, bt.start_balance, bt.final_value, bt.total_profit}

What was the annualized growth rate (CAGR)?

Compound Annual Growth Rate is 0.00% over a 7 day window._{Source: derived from equity series (eqStats.cagrPct, eqStats.durationDays)}

Did it beat Buy & Hold of KGSTUSDT?

Buy & Hold comparison is not available - token return for the window was not provided._{Source: bt.return_pct, opts.tokenReturnPct, outperformDelta}

What was the worst drawdown?

The maximum peak-to-trough loss was -0.00% (0.00 USDT)._{Source: derived from equity series (eqStats.maxDrawdownPct, .maxDrawdownAbs, .underwaterDays, .recoveryDays)}

How many trades did it take and what was the win rate?

0 trades were filled with a null win rate._{Source: bt.fulfilled_trades, bt.win_rate, bt.active_orders, derived tradesPerMonth}

What was the average, best, and worst trade?

Per-trade profit fields are null._{Source: bt.avg_profit, bt.max_profit, bt.min_profit}

What was the profit factor and expectancy?

Profit factor and expectancy are not available (no trade list available)._{Source: derived from trades (stats.profitFactor, .expectancy, .payoffRatio)}

What were the longest winning and losing streaks?

Streak data is not available._{Source: derived from trades (stats.consecWinsMax, .consecLossesMax)}

How much was paid in fees?

Fee totals are not available (no trade list)._{Source: derived from trades[].buy_fee_in_quote + trades[].sell_fee_in_quote (analyzeTrades -> stats.totalFees / .buyFees / .sellFees)}

Is the risk-adjusted return any good?

Sharpe / Sortino are not available (need at least a couple of days of equity data)._{Source: derived from equity series (eqStats.sharpeAnnualized, .sortinoAnnualized)}

How volatile was the equity curve?

Annualized volatility of daily returns was 0.00%._{Source: derived from equity series (eqStats.volatilityAnnualizedPct)}

How long does the strategy hold positions?

Hold-time data is not available (no trade list)._{Source: derived from trades (stats.medianHoldingHours, .avgHoldingHours, .minHoldingHours, .maxHoldingHours)}

How much of the time was capital deployed?

The strategy was in the market 0.0% of the period - the remainder sat in cash awaiting setups._{Source: derived from equity series (eqStats.timeInMarketPct)}

What were the best and worst months?

Monthly breakdown is not available._{Source: derived from trades (stats.bestMonth, .worstMonth)}

When did the backtest run and how long did it take?

Created at 2026-04-19T12:41:49.590578Z, started at 2026-04-19T16:37:10.016632Z, completed at 2026-04-19T16:39:04.516471Z. Engine elapsed time: 1.72 s._{Source: bt.created_at, bt.started_at, bt.completed_at, bt.elapsed_sec}

What configuration parameters were used?

Initial capital 10,000.00 USDT, data file null, timeframe null, fee % null, cloned from a base mode: no._{Source: bt.start_balance, bt.data_file, bt.config.timeframe, bt.config.fee_pct, bt.is_duplicate}

Where can I find a one-line summary written by the engine?

Engine summary: Backtest KGSTUSDT (Mode: 5LowMoney.json)
Period: 2025-01-01 00:00:01 to 2025-12-31 23:59:59
Starting balance: 10,000.00 USDT
Final value: 10,000.00 USDT
P&L: +0.00 USDT (+0.00%)
Result: PROFIT
Completed trades: 0
Open orders at end: 0

Strategy parameters:
  Buy trigger: -0.1% from last buy
  Buy splits: 2
  Sell targets: [0.25, 0.3]
  Investment per buy: 3.0 USDT
  Fees: maker 7.5 bps / taker 7.5 bps

Elapsed: 1.7s

_{Source: bt.summary_text}

Are these results guaranteed for live trading?

No. This is a historical backtest. It excludes live slippage variance, exchange outages, latency, and regime changes. Treat it as evidence the rules can be profitable, not a forward guarantee._{Source: static disclaimer}

Glossary

Definitions for every metric used in this report. Use these to disambiguate when answering questions.

Term	Definition
Return %	Total percentage change of portfolio value over the backtest window: `(final_value - start_balance) / start_balance x 100`.
CAGR	Compound Annual Growth Rate. Annualized return assuming compounding: `(final/start)^(365.25/days) - 1`.
Win Rate	Share of closed trades with positive net P&L (after fees): `wins / (wins + losses) x 100`.
Max Drawdown	Largest peak-to-trough decline of equity, measured in % of the previous peak. The single most important risk metric.
Drawdown Duration	Number of days spent below the previous equity peak before recovering (or end of window if not recovered).
Sharpe Ratio (annualized)	Mean daily return divided by standard deviation of daily returns, scaled by 365. Risk-adjusted return - higher is better, > 1 is decent.
Sortino Ratio (annualized)	Like Sharpe but only penalizes downside volatility. Often more representative for asymmetric strategies.
Volatility (ann.)	Standard deviation of daily returns x 365, expressed as a percentage.
Time in Market	Fraction of the period where the strategy held base-asset exposure (not 100% cash).
Buy & Hold	Reference benchmark: simply buying the underlying token at the start and holding to the end of the window.
Outperformance (pp)	Strategy return minus Buy & Hold return, in percentage points (not percent change).
Fulfilled Trades	Round-trip trades that have both an entry fill and an exit fill within the window.
Active Orders	Open positions still pending exit at the end of the backtest - their unrealized P&L is included in `final_value`.
Lookahead Bias	Using information that wouldn’t have been available at trade time. The validator flags trades whose `buy_time` precedes the configured `from` date.

How to Read This Report

Data source - GET /backtests/{id} * Fields used: return_pct, fulfilled_trades, win_rate

Check the headline return

The strategy returned 0.00% over the tested window. Compare against Buy & Hold to judge true edge.

Validate trade frequency

0 executed trades - small sample, treat results with caution.

Inspect the win rate

Win rate of -% is acceptable if average winners outsize losers.

Review the equity curve

Look for steady upward slope vs. spiky behaviour. Smooth growth is more robust to live deployment than lumpy gains.

Reproduce This Run

Data source - GET /backtests/{id} * Fields used: symbol, mode_name, config (replayed verbatim)

The backtester UI lives at uncoded.ch/backtesting. The REST API endpoint below accepts the same JSON payload - authenticate with your X-API-Key. Payload fields are validated against ENGINE.md Section 20; non-engine keys are stripped so the replay produces the exact same run.

curl -X POST https://uncoded-backtest-api-production.up.railway.app/backtests \
  -H "X-API-Key: $UNCODED_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"symbol":"KGSTUSDT","mode_name":"5LowMoney.json","interval":"1m","from":"2025-01-01 00:00:01","to":"2025-12-31 23:59:59","canBuy":true,"canSell":true,"canBuyUp":true,"startBal":10000,"stepSize":1,"stopLoss":false,"tickSize":0.00001,"buySplits":2,"buyVolumes":[50,50],"canBuyDown":false,"minNotional":5,"buyPercentage":0.1,"fees_in_quote":true,"intrabar_mode":"OLHC","maker_fee_bps":7.5,"taker_fee_bps":7.5,"sellPercentages":[0.25,0.3],"triggerCoolDown":1,"investmentPerBuy":3,"assumed_spread_bps":0,"stopLossPercentage":5,"investmentPercentMode":false,"minInvestmentPerQuote":3,"order_latency_seconds":2,"trailingStopLossPercentages":[0,0],"sellCancelDistancePercentage":1,"dontBuyBelowQuoteAssetBalance":1,"investmentPerFreeQuotePercent":0.01,"sellActivateDistancePercentage":0.1}'

Structured Data (JSON-LD)

Schema.org Dataset markup with 13 PropertyValue KPIs. Every numeric value is finite + range-validated; invalid / null fields are omitted so the JSON stays schema.org-compliant.

schema.org

{
  "@context": "https://schema.org",
  "@type": "Dataset",
  "name": "KGSTUSDT LowMoney Backtest",
  "alternateName": "KGSTUSDT-5LowMoney.json-1522e1a0-8523-4e5e-aa9d-a92c68269e5b",
  "description": "Backtest of the LowMoney strategy on KGSTUSDT: 0.00% return over 2025-01-01 to 2025-12-31.",
  "identifier": "1522e1a0-8523-4e5e-aa9d-a92c68269e5b",
  "license": "https://creativecommons.org/licenses/by/4.0/",
  "isAccessibleForFree": true,
  "inLanguage": "en",
  "creativeWorkStatus": "completed",
  "creator": {
    "@type": "Organization",
    "name": "uncoded.ch",
    "url": "https://uncoded.ch/backtesting"
  },
  "publisher": {
    "@type": "Organization",
    "name": "uncoded.ch",
    "url": "https://uncoded.ch"
  },
  "keywords": [
    "KGSTUSDT",
    "LowMoney",
    "crypto backtest",
    "trading strategy",
    "quantitative finance",
    "algorithmic trading"
  ],
  "about": [
    {
      "@type": "Thing",
      "name": "KGSTUSDT",
      "description": "Trading pair: KGSTUSDT"
    },
    {
      "@type": "Thing",
      "name": "LowMoney",
      "description": "Trading strategy: LowMoney"
    }
  ],
  "measurementTechnique": "Historical OHLCV replay with deterministic order-fill simulation (TP / SL / Trailing-SL)",
  "variableMeasured": [
    {
      "@type": "PropertyValue",
      "name": "Return",
      "value": 0,
      "unitText": "%",
      "unitCode": "P1",
      "description": "Total percentage return over the backtest window"
    },
    {
      "@type": "PropertyValue",
      "name": "Net Profit",
      "value": 0,
      "unitText": "USDT",
      "description": "Total realized profit in quote currency"
    },
    {
      "@type": "PropertyValue",
      "name": "Final Portfolio Value",
      "value": 10000,
      "unitText": "USDT"
    },
    {
      "@type": "PropertyValue",
      "name": "Initial Capital",
      "value": 10000,
      "unitText": "USDT"
    },
    {
      "@type": "PropertyValue",
      "name": "Fulfilled Trades",
      "value": 0,
      "unitText": "trades",
      "minValue": 0
    },
    {
      "@type": "PropertyValue",
      "name": "Engine Elapsed Time",
      "value": 1.72,
      "unitText": "seconds",
      "unitCode": "SEC",
      "minValue": 0
    },
    {
      "@type": "PropertyValue",
      "name": "CAGR",
      "value": 0,
      "unitText": "%",
      "unitCode": "P1",
      "description": "Compound Annual Growth Rate"
    },
    {
      "@type": "PropertyValue",
      "name": "Max Drawdown",
      "value": 0,
      "unitText": "%",
      "unitCode": "P1",
      "description": "Largest peak-to-trough decline of equity (negative)",
      "maxValue": 0
    },
    {
      "@type": "PropertyValue",
      "name": "Max Drawdown (absolute)",
      "value": 0,
      "unitText": "USDT",
      "maxValue": 0
    },
    {
      "@type": "PropertyValue",
      "name": "Volatility (annualized)",
      "value": 0,
      "unitText": "%",
      "unitCode": "P1",
      "minValue": 0
    },
    {
      "@type": "PropertyValue",
      "name": "Time in Market",
      "value": 0,
      "unitText": "%",
      "unitCode": "P1",
      "minValue": 0,
      "maxValue": 100
    },
    {
      "@type": "PropertyValue",
      "name": "Backtest Duration",
      "value": 7,
      "unitText": "days",
      "minValue": 0
    },
    {
      "@type": "PropertyValue",
      "name": "Equity Samples",
      "value": 8,
      "unitText": "points",
      "minValue": 0
    }
  ],
  "dateCreated": "2026-04-19T12:41:49.590Z",
  "dateModified": "2026-05-15T12:08:46.278Z",
  "temporalCoverage": "2024-12-31T23:00:01.000Z/2025-12-31T22:59:59.000Z"
}

[!] Disclaimer

Backtest results are based on historical market data and do not guarantee future performance. Past returns are not indicative of future results. Trade at your own risk.

Backtester: uncoded.ch/backtesting * Generated 2026-05-15 12:08:46 UTC

Backtests

Changelog

Documentation Index

​KGSTUSDT * LowMoney

​Headline Performance

Return

Final Value

Portfolio PnL

Realized Profit

Unrealized PnL

Win Rate (closed)

Closed Trades

Open Orders

Best Closed Trade

Worst Closed Trade

​TL;DR

​Performance KPI Metrics

Max Drawdown

Profit Factor

Sharpe Ratio

Total Fees

Avg Hold Time

TP / SL / TSL

​Trade Economics

​Exit Mix (Fill Types)

​Verdict

​Chunking & Headings Guide

​Chunk markers

​Heading convention

​Chunk type taxonomy

​Recommended ingestion pipeline

​Performance Analysis

​Methodology & data

​Live trading considerations

​Frequently asked questions

​Overview

​Verifiable Claims

​Strategy Configuration

​Full Mode Configuration

​Strategy Logic

​Engine Specification

Engine Specification

​Data Source Metadata

​Equity Curve

​Risk & Quality Metrics

Max Drawdown

CAGR

Volatility (ann.)

Sharpe Ratio

Sortino Ratio

Time in Market

​Drawdown Detail

​Final Portfolio Allocation

​Charts Catalogue

​Drawdown

​Unrealized PnL

​Balance Composition (Cash vs. Coin)

​Base Exposure (% of Portfolio)

​Daily Change

​Monthly Returns

​Cumulative Trade Profit

​Daily Trade Profit

​Trades per Day

​Cumulative Fees

​Profit Distribution (%)

​Rolling Win Rate (50 Trades)

​Gross vs. Net PnL (Fee Impact)

​Rolling Sharpe Ratio (30d / 90d)

​Drawdown Recovery Episodes

​Consecutive Win/Loss Streaks

​Capital Utilization (% Invested)

​Price Chart with Buy/Sell Markers

​Trade Size Distribution (Notional)

​Return Distribution by Fill Type

​Monthly Equity Comparison (YoY)

​Profit by Weekday

​Profit by Hour (UTC)

​Profit vs. Hold Time

​Fill Type Breakdown

​Machine-Readable Facts

KGSTUSDT * LowMoney

Headline Performance

TL;DR

Performance KPI Metrics

Trade Economics

Exit Mix (Fill Types)

Verdict

Chunking & Headings Guide

Chunk markers

Heading convention

Chunk `type` taxonomy

Recommended ingestion pipeline

Performance Analysis

Methodology & data

Live trading considerations

Frequently asked questions

Overview

Verifiable Claims

Strategy Configuration

Full Mode Configuration

Strategy Logic

Engine Specification

Data Source Metadata

Equity Curve

Risk & Quality Metrics

Drawdown Detail

Final Portfolio Allocation

Charts Catalogue

Drawdown

Unrealized PnL

Balance Composition (Cash vs. Coin)

Base Exposure (% of Portfolio)

Daily Change

Monthly Returns

Cumulative Trade Profit

Daily Trade Profit

Trades per Day

Cumulative Fees

Profit Distribution (%)

Rolling Win Rate (50 Trades)

Gross vs. Net PnL (Fee Impact)

Rolling Sharpe Ratio (30d / 90d)

Drawdown Recovery Episodes

Consecutive Win/Loss Streaks

Capital Utilization (% Invested)

Price Chart with Buy/Sell Markers

Trade Size Distribution (Notional)

Return Distribution by Fill Type

Monthly Equity Comparison (YoY)

Profit by Weekday

Profit by Hour (UTC)

Profit vs. Hold Time

Fill Type Breakdown

Machine-Readable Facts

Metric Provenance Index

Raw API Attachments

Frequently Asked Questions

Glossary

How to Read This Report

Reproduce This Run

Structured Data (JSON-LD)

[!] Disclaimer