MCP App Store
by KeenEthics
Tradetron icon

Tradetron MCP Server for ChatGPT

By Tradetron

Overview

Tradetron is a no-code platform for building automated trading strategies. Connect your Tradetron account and describe a strategy in plain English (options, futures or equities). It is built as a strategy template in your account and checked against Tradetron's strategy rules before it is saved. You can backtest a strategy on historical data, run it in Live Offline (live prices, no orders sent) to watch it work, find out why a deployed strategy did or did not take a trade from its engine and broker logs, change one part of a strategy without rebuilding it, and read your own performance reports. You can also look up keywords, supported brokers, tradable symbols and market hours while you build. You sign in with your own Tradetron account, and every tool works only on that account. This app never places a live order: going live is done by you on the Tradetron website. This app does not provide investment advice or recommend what to trade. Backtested and simulated results do not guarantee future performance, and trading involves risk of loss.

How to connect

  1. ChatGPT: Open the Tradetron listing in the ChatGPT app directory and choose Connect. ChatGPT listing Tradetron exposes 70 tools here.

Tools

tt_apply_strategy_patch

ChatGPT
Apply a JSON-Patch (RFC 6902) to an existing strategy. exchange_brokers: {exchange: broker_id}. Send ONLY on the re-call after a STRATEGY_EXCHANGE_BROKER_REQUIRED refusal, with the broker the USER picked from details.missing[].brokers. Never pick one yourself. On success relay data.subscriber_broker_warning if present. MOVING ONE VALUE EVERYWHERE IT APPEARS — use rewrite, not patch. rewrite={"dimension": "timeframe", "from": "1m", "to": "5m"} changes the candle timeframe at EVERY site in the strategy in one small call: both text forms and the builder tree of every condition, plus every tt_get_data call in the Python block. Hand-authoring that is not a realistic ask — condition_json is a JSON-ENCODED STRING, so no pointer reaches inside it and a three-character change means re-sending every builder tree in the strategy. Prefer one rewrite call over per-condition patches or splitting the work across calls. The three-representation rule below is satisfied automatically, and the partial-edit guard proves no site was left on the old value. from may be written any way ('1 minute', '1min', '1m'); the canonical token is what gets written. A miss returns the timeframes the strategy DOES hold, so the retry is exact. rewrite and patch compose — explicit ops win on their own fields. Underlying swaps are NOT rewritable (lot size, strike step, expiry and the instrument id all move with the symbol); the refusal says so and names tt_check_underlying_support. LIVE-EDIT CONFIRM GATE: if this template is DEPLOYED, has SUBSCRIBERS, or is PUBLIC, a NON-dry-run call refuses once with LIVE_EDIT_CONFIRMATION_REQUIRED — carrying the blast radius, the live-position consequences, and a copy alternative. RELAY those to the user, ask one confirm question, and only after the user explicitly agrees re-call with the SAME arguments plus live_edit_confirmed=true. Never set it on your own initiative. dry_run=True (the default) is never gated. A patch that removes or blanks the strategy's Universal Exit is refused (STRATEGY_EDIT_UE_REMOVED) unless allow_universal_exit_removal=True. When ADDING a repair condition, insert it BEFORE the set's Exit condition (explicit index, not "/conditions/-") — conditions evaluate in array order and a repair after the Exit is dead code (CONDITION_ORDER_EXIT_BEFORE_REPAIR). ANY change to a leg's underlying — INCLUDING a same-exchange swap such as Crudeoil → NaturalGas, not only across asset classes — requires re-deriving every dependent field in the SAME patch: expiry, expiry_type, strike, strike_type, strike_display, strike_json, product_type, qty_type, and the numeric instrument id (set it to 0 to let the server resolve it — a stale non-zero id is trusted as-is and never re-derived). Call tt_check_underlying_support(<new symbol>) BEFORE composing the patch: lot size and strike step differ between underlyings (Crudeoil 100, NaturalGas 1250), so the leg cannot carry over. Expiry keyword families: NFO/BFO Current Week/Month Expiry · MCX MCX Fut Expiry / MCX Option Expiry · crypto Crypto Current Day/Week/Month Expiry (perpetual = literal 2099-12-31). Leaving any of them stale is refused as LEG_SYMBOL_REFERENCE_DESYNC — before that guard existed, a same-exchange swap validated 0 errors / 0 warnings and traded the OLD contract. Use this for SURGICAL structural edits — adding / removing / reordering / modifying an individual set, condition, or leg without re-sending the whole strategy. The post-patch state is POSTed as the clean create-shape and round-trip-verified by content count; it FAILS LOUD (STRATEGY_PATCH_CONTENT_DROPPED) if TT drops content. For a full sets-array replacement or scalar fields, tt_update_strategy also works. TT INJECTS READ-SIDE SCAFFOLDS (verified against the live API 2026-08-07): the GET/fetch response appends inert blank envelopes — Add Repair + Exit per set, and Add Repair + Repair Once/Overnight Protection in the last/Universal-Exit set — so the fetched condition count EXCEEDS what was sent (e.g. 13 sent → 15 fetched). These rows are display scaffolds from TT's read transforme…

tt_apply_strategy_patch_chunked

ChatGPT
Chunked tt_apply_strategy_patch, for an edit too large to send in one tool argument. WHEN TO USE: only after a normal tt_apply_strategy_patch call could not be emitted in one piece. Before reaching for this, check whether rewrite does the job — moving a timeframe across a whole strategy is ~60 bytes with rewrite and hundreds of KB without it. Between rewrite and chunking, a large edit can normally be completed without asking the user to do it by hand. PROTOCOL. Encode the WHOLE CALL as JSON — not the strategy: {"strategy_id": 123, "patch": [ ...ops... ], optional when rewrite is given "rewrite": {"dimension": "timeframe", "from": "1m", "to": "5m"}, "dry_run": true, "live_edit_confirmed": false} base64(gzip(...)) it if you can compute that; plain JSON is accepted too (the decoder is tolerant — do NOT hand-write base64). Split the string into N pieces and send each with the same draft_id and total_chunks. Earlier calls return {status: "chunk_received", ...}; the final call runs the patch and returns exactly what tt_apply_strategy_patch returns. Resending the same (draft_id, chunk_index) replaces that chunk — safe to retry. Drafts are GC'd 5 minutes after the last write. Assembly is one-shot: if the patch itself is rejected, re-upload the chunks. LIVE TEMPLATES: a non-dry-run edit to a deployed, subscribed or public template refuses once with LIVE_EDIT_CONFIRMATION_REQUIRED. After the user explicitly agrees, re-upload the chunks with live_edit_confirmed=true (this argument on the final chunk, or the same key inside the JSON). Never set it on your own initiative.

tt_ask_tt

ChatGPT
Ask TT — answer any question about Tradetron from the indexed knowledge base (FAQ, help docs, blog, forum). Cites sources. USE WHEN: user asks about Tradetron product features, capabilities, pricing tiers, common workflows, "can I do X on Tradetron", "how do I Y", or any question ABOUT TRADETRON-AS-A-PLATFORM (NOT about authoring a specific strategy). DO NOT USE for: - Broker-support questions ("do you support X?", "what brokers are connected?", "any US brokers?") → use tt_check_broker_support or tt_list_brokers. Those are deterministic against a bundled catalog; this tool is RAG-based and may miss or misreport. - Authoring a new strategy → use tt_create_strategy + the validate / keyword-lookup tools instead. - Editing / fetching an existing strategy → use tt_get_strategy / tt_update_strategy. - Looking up a specific keyword → use tt_lookup_keyword. Returns a structured retrieval result for the calling assistant to turn into the user-facing answer. The result describes how it was assembled (synthesis_instructions): - definitive_no_answer non-null → Tradetron has no such feature; the field carries the exact wording so the answer is not an invented workaround. - escalate=True → the knowledge base cannot answer; the crisp_handoff_payload lets the user reach a support agent. - Otherwise the answer is grounded in the cited sources; include a source URL inline when a source carries one (catalog-backed sources have a title but no URL — cite them by name).

tt_backtest_compare

ChatGPT
Put two or three finished backtests side by side. FREE — reads runs already paid for, runs no engine, charges nothing. This is the second half of research. One run tells you what happened; the comparison tells you whether the change you made did anything. READ attribution BEFORE ANY NUMBER, and say what it says. A delta is attributable to a cause only when EXACTLY ONE run input differs — the window, the candle frequency, the type, the expiry, the fill price or the strategy. If more than one moved, this is two different experiments and no difference can be pinned on any of them. If none moved, the gap is the engine's own run-to-run variation, not a result. THERE IS NO WINNER FIELD, deliberately. "Which is better" over a short window is how people talk themselves into noise. You get deltas, a paired daily-difference test, and the job of drawing the conclusion in the open. daily_test.verdict is not a footnote — quote it alongside the delta. A bigger number over a few dozen days is usually chance, and the test says so. Metrics in not_compared were withheld on one side for being unsupportable; subtracting them would launder them back in. Never do it. Args: job_ids: 2-3 ids; the first is the baseline. sections: extra sections per run.

tt_backtest_idea

ChatGPT
The backtest playground: "what would have happened if I bought X whenever Y, and sold it Z later?" — for NSE stocks/ETFs on daily candles. Use THIS instead of the tt_validate_markdown -> tt_create_strategy -> tt_backtest_strategy ladder for any single-stock, daily, long-only what-if. It builds the strategy, backtests it and cleans up itself. CALL 1 (free, instant, no login needed): symbol + entry + an exit (hold_days and/or exit). Returns a daily PREVIEW replay — trades, win rate, net return vs buy-and-hold — plus the validated strategy it would run. Report the preview with its limits: it is not the engine. CALL 2 (paid): the same arguments with run_backtest=true. It creates a temporary "Playground" strategy in the user's account and returns the PRICE QUESTION (confirmation_required, price, wallet balance). Nothing is charged. Ask the user; only after a clear yes, call retry_call (confirmation_token + confirm_charge=true). That submits to Tradetron's backtest fleet, waits for it server-side, and returns the report's own headline numbers and report_url. If still running, it returns job_id — call tt_backtest_idea(job_id=...) once when the user asks again. EXIT IS REQUIRED AND HAS NO DEFAULT. If the user did not say when to sell, ASK. Never pick an exit, a threshold or a window for them without saying so (the window defaults to the 3 years ending 35 days before today and the response says when it did). Backtests may only use data at least 35 days old (exchange rule): an end inside the last 35 days is refused with the latest allowed date; offer that date instead. The temporary strategy is DELETED once its backtest finishes (or if the user never confirms the price). keep_strategy=true keeps it. Scope: long only (Indian delivery cannot be held short overnight), NSE cash, daily candles. Intraday or options ideas: tt_check_edge -> tt_promote_to_strategy.

tt_backtest_result

ChatGPT
A finished backtest's NUMBERS — the figures from its own report, as data. THIS IS FREE. It reads a run the user has already paid for; no engine runs and nothing is charged, however many times it is called. Slice the same run as often as the question needs. Use it the moment tt_backtest_status says done. tt_backtest_status returns a report_url and no figures, on purpose; this is how you read them without a browser. tt_backtest_trades remains the way to page raw FILLS — this gives you the analysis over them. Sections (ask by name; the default set is the cheap ones): headline meta costs weekday drawdowns monthly exit_attribution concentration trade_stats setwise stats_table <- default series sub_windows grade timing distribution underwater regime rom benchmark walk_forward montecarlo quality trades positions sets underlyingwise underlyingwise is P&L, trades and ROI PER UNDERLYING — the same split the report page renders under BREAKDOWNS -> Underlying-wise. Ask for it on any multi-instrument book: the default response announces it in section_notes.underlyingwise when the run holds more than one. Do not re-derive it by paging trades. sub_windows is summarised by default — six trailing windows are six COMPLETE nested results (measured: 91 KB on a 42-trade run). Each block names what was dropped under _omitted, and section_notes reports approx_chars. Pass caps={"sub_windows_full": true} for the whole blocks. THREE THINGS THIS DELIBERATELY DOES NOT DO, and you must respect them: 1. caveats[] is not decoration. Each entry names, in affects, the metric keys it taints. Read it BEFORE quoting any figure. Never present a run carrying a high-severity caveat as evidence of an edge. 2. A risk-adjusted figure the book cannot support is ABSENT, not zero — see section_notes.headline_withheld for which and why. Do not fill the gap from the report page, and do not estimate it. 3. section_notes.<name>.basis says whether a section is gross or net. The headline is net; Monte Carlo, PSR, timing and distribution are gross. Never put a net figure and a gross one in the same sentence without saying so. A section marked single_trial (montecarlo, quality/PSR) assumes ONE backtest was run. After comparing variants it reads high by construction and is not a probability that the strategy works. Say that, or omit it. Args: job_id: 'ttbt-...' or a bt_id from tt_list_backtests. sections: section names; omit for the default set. caps: per-section row caps, e.g. {"trades": 200}; plus {"sub_windows_full": true} to unsummarise the trailing windows.

tt_backtest_status

ChatGPT
Check a backtest's completion and fetch what its engine returns. A job_id need not come from the user: tt_list_backtests returns every run in their account with its job_id already attached. Call this after tt_backtest_strategy. A backtest takes ~10-75s; if it's not finished yet this returns state 'queued'/'running', so poll it after a short beat. THE SHAPE DEPENDS ON WHICH ENGINE SERVED THE RUN (the response's engine field says which): - engine 'tradetron-fleet' (job ids 'ttbt-…' — the normal path since 2026-08-25): completion + report_url ONLY. You may also pass the BARE backtest id the user reads off their Tradetron report page or the trades-CSV filename (e.g. 10053270260902); it is normalised onto this route, so a run started on the website is reachable too. The numbers live on the public per-run report page; this response carries NO results block, csv_url or raw payload — present report_url and read the numbers there, never invent a P&L figure here. To READ the run without a browser (any chat channel, or the ttmcp CLI), call tt_backtest_trades with its job_id: that returns the fills plus a summary computed over all of them. - engine 'btengine' (16-hex job ids — sweeps and non-default-knob runs): done => {summary_md, results:{net_pnl, roi_pct, max_drawdown, charges, trading_days, fills, currency, ...}, report_url, csv_url}, plus raw (the untouched btengine payload). - failed (either engine): {done: True, failed: True, error, summary_md (incl. auto-refund note)}. - not_found: Tradetron is returning no record for this id — it is wrong, or the run belongs to another account. TERMINAL: do not poll again, ask the user to re-check the id on their Backtests page. - unavailable: the status could NOT be read. This is NOT evidence the run is progressing — never report it as "still running". Retry once, then send the user to their Backtests page. RELAY summary_md verbatim (it's unit- and currency-correct — crypto is USD, not ₹). Then add the report_url as a clickable link. If the submit charged the user (the tt_backtest_strategy billing block), remind them of that charge in the same message, quoting the submit's own value (never a hardcoded figure); on a failed run, the fee auto-refunds — say so.

tt_backtest_strategy

ChatGPT
Submit a backtest of one of the user's Tradetron strategies on historical market data. Returns {job_id, watch_url, status_url}; the run finishes in the background, so poll tt_backtest_status with job_id and give the user the report_url it returns. The report is served at a link anyone holding it can open. Pass exactly one of strategy_id (a template id or deployed SID in the user's connected account) or template (a strategy object from tt_create_strategy). To backtest an idea described in words, create the strategy first with tt_create_strategy; to backtest by name, find its id with tt_list_my_strategies. start / end are 'YYYY-MM-DD'. Backtests may only use data at least 35 days old: a later end is refused, without charge, with BT_WINDOW_TOO_RECENT and latest_allowed_end; offer that date. type is 'auto' (default), 'intraday' or 'positional'. When the strategy does not show which, the tool returns BT_TYPE_CONFIRMATION_REQUIRED with one question and submits nothing; ask it, then re-call with type and bt_type_confirmed=true. trade_price (Open, Close, Avg of Open and Close), capital, candle_freq (minutes), slippage_bps, tt_match and oos_pct (0-50, holds back that share of the window as out-of-sample) tune the run. CHARGES: a backtest beyond the daily free allowance is charged to the user's Tradetron wallet. A chargeable run first returns BT_CONFIRM_CHARGE with the price, the wallet balance and a confirmation_token, and submits nothing. Tell the user the price, wait for a clear yes, then call again with {confirmation_token, confirm_charge: true}. Never set confirm_charge on your own. A rejected or failed run is refunded. If the balance is too low the tool says so; adding funds is done by the user on the Tradetron website. Backtested results do not guarantee future performance.

tt_backtest_sweep

ChatGPT
Sweep ONE strategy parameter across a grid on Tradetron's own backtest fleet — a run per value; returns a job id, and the report link comes from the status poll. Use to answer "which entry time / strike offset / SL is best?" without hand-editing and re-submitting N backtests. SINGLE-AXIS ONLY: one search variable, N values. It is NOT a multi-parameter grid — to explore a second parameter, run a second sweep. BILLING (when enabled server-side): a sweep is charged PER VARIANT — every value in values is one engine run debited at the per-run backtest fee from the user's Tradetron WALLET, so N values cost N x the per-run fee (e.g. 5 values = 5 x the fee). The same consent gate as tt_backtest_strategy applies: a chargeable sweep first returns {code: BT_CONFIRM_CHARGE, price, wallet_balance} with the TOTAL price for all variants and submits NOTHING — relay the exact amount and the variant count to the user, and only after they agree re-call with the SAME arguments plus confirm_charge=true. A rejected or failed sweep is auto-refunded. A successful submit carries {billing: {charged, variants, rate, wallet_balance}} — mention the total charge in one short sentence, never as a surprise. Args: confirm_charge: set True ONLY after the user has been told the exact total fee (per-variant fee x number of values) and agreed to it. Never set it on your own initiative. template: the strategy object (with a 'sets' array), passed INLINE. Unlike tt_backtest_strategy, this tool has NO strategy_id parameter: for a strategy already saved in the user's account, call tt_get_strategy(strategy_id) first and pass its data.strategy here as template. Fetching also carries the template's id, and that id is what the fleet sweeps. A hand-built inline template has no id, so it is REFUSED uncharged ("isn't saved in your Tradetron account") — save it with tt_create_strategy, re-fetch it with tt_get_strategy, and sweep THAT object. The refusal says "backtest by strategy_id" because it is shared with the backtest tools that take one; here it means that round-trip. start, end: 'YYYY-MM-DD' window; end must be at least 35 days before today (BT_WINDOW_TOO_RECENT otherwise, refused before any charge). type / trade_price / capital / candle_freq / slippage_bps / tt_match: identical meaning to tt_backtest_strategy. search: a parameter of THIS strategy to vary — e.g. an entry time "0930", a strike offset, an SL number. Tradetron validates it server-side against the strategy's own parameters, and does so on the routing check, so a name the strategy does not carry is refused FREE and BEFORE the price question, quoting Tradetron's own sentence ("'X' is not a parameter of this strategy. Pick one from the list."). That arrives as {ok: False, error} — take the list it names and re-call. It is NOT a fuzzy substring match over the template JSON. values: the grid to try — 2 to 10 strings (hard limits; validated here before submit). One sequential engine run per value. oos_pct: per-variant WALK-FORWARD fold, default 30 (the service clamps 10–50), so each variant is judged in-sample vs out-of-sample — pick by IS, judge by OOS. name: optional label for the run; defaults to the template name. TIMING: variants run SEQUENTIALLY, ~300s each, so a 10-value intraday sweep can take many minutes. This is submit-and-watch — open watch_url for progress; it is never synchronous. A sweep counts as ONE inflight job; our single source IP allows max 4 concurrent backtests total (shared across all MCP backtest tools). RESULTS: poll with tt_backtest_status. The per-variant ranking currently renders in the HTML report (report_url in the status). A machine-readable per-variant summary is being added service-side; once live, tt_backtest_status will also carry structured per-variant results in its summary — this tool passes through whatever summary/results the status returns and does not require them to be present yet. Returns {ok, job_id, watch_url, status_url, state, note} (+ fidelity_caveat as tt_backtest_strategy). On a bad search / validation reject: {ok: False, error, findings}.

tt_backtest_trades

ChatGPT
What a finished backtest actually TRADED — its fills, summarised over the whole run and returned one readable page at a time. AUTH-REQUIRED. Answers the question tt_backtest_status cannot: that tool returns completion and a report_url, and on a Tradetron-fleet run the numbers live only on that web page. A client that cannot open a browser (any of the chat channels, or pip install ttmcp) could run a backtest and never read it. Call this after tt_backtest_status says the run is done, or on any bt_id from tt_list_backtests. Returns: summary computed over EVERY fill: fills, buys, sells, instruments, first_fill/last_fill, and net_pnl WHEN the run's fills carry a P&L column (net_pnl_column names which one). A figure that is ABSENT was not in the data — say so and point at report_url rather than deriving one. trades one page of fill rows (count, offset, has_more, next_offset). Never ask for everything: one run in the QA set carried 9,823 fills. csv_url / report_url when Tradetron returns them. A run with no fills is a RESULT, not a failure — the entry conditions never triggered in that window; the response says so in note. Args: job_id: 'ttbt-...' from tt_backtest_strategy, or a bt_id from tt_list_backtests. A 16-hex btengine job id is rejected with a pointer back to tt_backtest_status, which already carries that engine's own results block and csv_url. limit: trade rows per page (default 25, max 200). offset: trade rows to skip.

tt_backtest_workbench

ChatGPT
OPEN A STRATEGY FOR BACKTEST WORK. Start here, not with a submit. Give it a template id and it answers, in one call: is this yours, what has already been run on it, what those runs can tell you for FREE, and what a new run would cost. AUTH-REQUIRED. It never submits and never charges. WHY IT MATTERS: reading and re-slicing a run the user already paid for is free and unlimited; a NEW run is a fresh charge. You cannot tell which side a question falls on without knowing what runs already exist — so a model that skips this either re-buys a backtest the user already has, or refuses to explore because it assumes everything costs. Both waste the user's money or their time. HOW TO USE THE ANSWER: - runs.rows with finished: true → answer from these first, via tt_backtest_result. Slice them as many times as the question needs. - next_run.changes_that_need_one is the definitive list of what forces a new paid run: the strategy body, the dates, the type, the expiry, the fill price, the candle frequency. NOTHING ELSE DOES. - next_run.quote is Tradetron's own price. Quote it verbatim; never compute or estimate one, and never state a price when it is null. TEMPLATE_NOT_YOURS is terminal — do not retry the id, and do not guess another. Ask the user, or call tt_list_my_strategies. Args: template_id: the strategy template to open. start/end: only needed to price a prospective new run. run_limit: past runs to list (default 20, max 100).

tt_broker_integration_guide

ChatGPT
Deterministic, KB-grounded step-by-step for connecting a broker / webhook / data feed to Tradetron (TradingView/Chartink/API/virtual server). Serves stable steps from the curated KB feed instead of RAG; NEVER invents broker-specific steps. Call with NO arguments first when unsure of the topic: that returns mode:'index' — the full menu of ~24 curated topic ids (per-broker connect guides plus tradingview_webhook, chartink, generic_webhook_api, virtual_server, ...) with confirmed flags and the generic connect flow. A user asking about a 'static IP' means the virtual_server topic: Tradetron does not sell a static IP (NSE rules bar empanelled vendors from selling public IPs) and never call it one in the reply. Then pass topic = one id from that index, or free text in broker (broker name or mechanism). The topic list is data-driven — the index, not this docstring, is authoritative. For whether a broker is supported/connected use tt_check_broker_support / tt_list_brokers; for product how/why use tt_ask_tt — this tool is for SETUP procedures.

tt_check_backtestability

ChatGPT
Pre-flight a template against Tradetron's NATIVE backtest (the Backtest button in ASB): will the run succeed, before the user submits it? Answers a different question from tt_validate_markdown — a template TT accepts can still fail its backtest, because the BT engine implements a subset of the live keyword surface and the BT data store covers a subset of exchanges. Checks: (1) every function token in conditions/legs/variables exists in the BT engine namespace (e.g. Leg SL trail, PCR, Total OI do NOT); (2) the exchanges touched have backtest data — NSE/NFO/BFO run (SENSEX/BANKEX options from 2023-07), MCX futures + options run (FastBT launch segment), Delta-India BTC/ETH daily options run, US venues run per-underlying (SPX/XSP/NDX/VIX index options + an 18-symbol stock/ETF option list); non-Delta crypto exchanges remain blocked; (3) the window doesn't predate coverage; (4) error-prone classes (custom python, runtime-var underlying) are flagged. Since 2026-08-25 EVERY backtest — web or chat — runs on FastBT; this check pre-flights that engine. Call it before tt_backtest_strategy or whenever the user asks "can I backtest this?". Args: template: the strategy object, passed INLINE — tt_create_strategy output or a TT v2 export (both shapes accepted). Unlike tt_backtest_strategy, this tool has NO strategy_id parameter: for a strategy already saved in the user's account, call tt_get_strategy(strategy_id) first and pass its data.strategy here as template. start, end: optional 'YYYY-MM-DD' backtest window — enables coverage-window checks. An end inside the last 35 days is a BT_WINDOW_TOO_RECENT blocker (backtests may only use data at least 35 days old; the finding names the latest allowed end date). Returns {backtestable, verdict, confidence, blockers[], warnings[], stats, engine_build, billing, run_type_recommendation}. Blockers mean the run WILL fail; warnings mean it should run but may error or silently skip data. BRANCH ON verdict, NOT ON backtestable. The boolean has two values and this check has three answers: "blocked", "backtestable", and "unknown" — one or more checks could not run (checks_skipped says which and why), or the template carries a reference tt_create_strategy itself refuses. In the "unknown" state backtestable still reads true, and it means UNCHECKED: an exchange absent from the coverage table is judged by nothing, while one that is IN it and has no data is a clean false. Never report "unknown" to a user as "yes, this will backtest" — say which check did not run. Each finding is {code, message, where?, fix?, detail?}: message is written FOR THE USER (what is wrong, then what to change) and where names the place the way ASB numbers it ("Set 1 -> Condition 18"), so relay them as they stand rather than rewriting them. detail is the engineering explanation — read it to reason, do not paste it at the user. The billing block carries the CONFIGURED per-run price and whether backtest billing is enabled, so the cost is visible at the point of decision — for the LIVE wallet balance and a top-up link call tt_wallet_balance (this check makes no network calls). run_type_recommendation = {type, confidence, evidence[]} — the intraday-vs- positional reading derived from the template's own structure (same detector the submit path uses). Present it as the DEFAULT when asking the user which way to run; both remain runnable.

tt_check_broker_support

ChatGPT
Check whether Tradetron is connected with a given broker. Deterministic lookup against the bundled broker catalog (sanitized snapshot of TT's brokers table — active integrations only). Use this BEFORE answering any "do you support broker X?" / "can I trade through Y?" question — it is authoritative. Do NOT guess from training data; if a broker is not in this catalog, Tradetron is not connected with it. Matching is case-insensitive and whitespace-insensitive ('5paisa', '5 Paisa', '5Paisa' all collapse to one key). Substring matches also surface — 'kotak' returns every Kotak variant. Returns: supported: True if at least one match exists. matches: broker rows (name, country, exchanges). message: one-liner safe to relay to the user. synthesis_instructions: guidance for you, not text for the user. resolved_from_alias: set when a common name ('IBKR', 'Angel Broking') was resolved to the catalog's own name. Common abbreviations and former names are recognised ('IBKR', 'Angel Broking'). A partial-name match counts as supported ('kotak' matching Kotak Neo = YES). When supported=False, phrase it as "not currently integrated" and offer a live agent to raise the request — never a flat "no". When supported=True but tt_broker_integration_guide has no curated steps, it is still supported — offer a live agent to get the user connected. For listing all supported brokers (e.g. "what brokers do you support in the US?") use tt_list_brokers instead.

tt_check_crisp_response

ChatGPT
Poll a Crisp conversation for new agent (operator) messages. USE WHEN: the user has asked whether the agent has replied yet ("any update?", "did they respond?"), or you're about to surface their next prompt and want to slot in any pending agent message first. session_id comes from a prior tt_open_crisp_conversation call. since_timestamp_ms is a cursor — pass back the latest_timestamp from the previous poll to skip messages you've already shown the user. On the first poll pass 0. Returns only operator-side text messages — the user's own echoed messages and the bot's private context note are filtered out. Each message has a content string you can surface to the user, plus a timestamp you should remember as the new since_timestamp_ms for the next call. If messages is empty, no new replies. Say "no reply from the agent yet" — and do NOT promise one is coming: this surface has no signal for whether support is online, so never state or imply that someone is about to answer. If the user is waiting on something urgent, give them help.tradetron.tech and +91 80 4718 9100 as well.

tt_check_edge

ChatGPT
Has this rule ever actually made money? The FREE screen that kills bad ideas before anyone spends a paid backtest on them. For a single NSE STOCK on DAILY candles ("buy X when RSI < 30, sell a week later") use tt_backtest_idea instead — it takes stocks, daily bars and hold-N-days exits, and runs the real engine in one more call. rules is a comma-separated list from tt_scan_instruments, e.g. "price_above_ema20,macd_above_signal". direction is long or short. exit_rule is 'bars:N', 'opposite', or 'session_close'. DIRECTION AND EXIT ARE REQUIRED AND HAVE NO DEFAULTS, on purpose. An indicator reading says what to WATCH; it does not say which way to trade it or when to get out. If the user has not said, ASK — do not pick. A quietly-invented exit produces a strategy that looks like their idea and behaves nothing like it. THIS IS NOT A BACKTEST and must never be called one. It trades the SPOT, not options; it applies no brokerage, no statutory charges, no slippage and no sizing. Report the limits string alongside any number. A positive result means only that the idea has EARNED a real backtest — say exactly that, then offer tt_promote_to_strategy, which is the only tool that takes a screened rule set (it builds a validated draft, creates nothing and charges nothing). Do NOT offer tt_backtest_strategy here: it takes a template or a strategy_id, not rules, and it can debit the user's wallet. The order is tt_promote_to_strategy -> tt_create_strategy -> tt_backtest_strategy. Never annualise it, never call it profit, never present it as expected return. Entries are transitions into the rule set, taken at the NEXT bar's open — never the close that produced the signal. Positions do not overlap. DATA RULE: the window is lookback_days ENDING 35 days before today (window.ends) — replays of a trading rule may only use data at least 35 days old (exchange rule). Name that end date; never describe the result as covering recent sessions. Returns trades, win rate, total, median, payoff, max drawdown, a trade_list of the most recent 25 (with trade_list_scope saying so — the headline figures are over ALL trades and must not be recomputed from that list), plus the wire conditions for the rules so nothing is retyped on the way to a strategy. No auth required.

tt_check_underlying_support

ChatGPT
Check whether Tradetron supports trading a given underlying. Deterministic lookup against the bundled underlying catalog (snapshot of TT's underlying table). Use this BEFORE answering any "can I trade X?" / "is X tradable?" / "is X listed?" question — it is authoritative. Do NOT guess from training data; if a symbol is not in this catalog, Tradetron does not support trading it. Matching is case-insensitive and alias-aware: 'nifty' / 'NIFTY 50' / 'Nifty50' all collapse to the same canonical symbol; 'BANKNIFTY' resolves to 'NIFTY BANK'. Returns: supported: True if at least one match exists. resolved_to: canonical symbol when the input was an alias. matches: [{symbol, exchanges, instrument_types, lot_sizes, kinds, emitter_buildable}]. kinds is the field that tells a CASH equity from a derivative — an equity typed OPTSTK is not an option, and nothing else in the response says so. emitter_buildable (also at top level) says whether the builder can author a leg on it. Both were returned undocumented. message: one-liner safe to relay to the user. may_be_a_name: true when the query looks like a company or index NAME rather than a ticker — do not report it as unsupported. symbol_candidates: on a miss, symbols whose company/index NAME matches the query ("Reliance Industries" → RELIANCE) — re-check the intended one by symbol. synthesis_instructions: guidance for you, not text for the user. For listing all underlyings (e.g. "what stocks are on Tradetron?" or "which index options can I trade?") use tt_list_underlyings.

tt_create_signal_bridge

ChatGPT
Build a WEBHOOK-DRIVEN multi-symbol strategy ("Signal Bridge") for a basket, create it in the user's account, link its API token in HYBRID mode, and return everything needed to drive it from outside. Use when the user wants to trade from THEIR OWN signals (their code, TradingView, a PMS/advisory feed, a WL partner) rather than Tradetron conditions: "send BUY/SELL from my python", "signal-driven portfolio", "API-linked template", "PMS basket with webhook signals". What the template does (one Long + one Short set per symbol, one python block): accepts <SYMBOL> = BUY / BUY EXIT / SELL / SELL EXIT via the webhook; rejects invalid signals with a reason (<SYMBOL>_msg); sizes by Fix / Capital % / Capital Risk % / Allocation Method 1; per-trade target & SL (money/points/%); master target/SL with reset; max open positions; max capital per symbol; working days; session window; intraday square-off; square-off-all on TP/SL; futures/options expiry-day exit. Every setting is a runtime variable the webhook can change while live. OPTIONS: an option item is a relative rule (CE/PE, strike steps from ATM SPOT, expiry label) resolved when a BUY/SELL is accepted; the strike is pinned for that entry and the exit closes the contract that was entered. Its variable is <UNDERLYING>_<CE|PE>_<ATM|ATMP<n>|ATMM<n>> plus _NW/_CM/_NM when the expiry is not the underlying's default (Current Week for NIFTY 50/SENSEX, Current Month otherwise) — e.g. NIFTY50_CE_ATM, NIFTY50_PE_ATMM1, NIFTYBANK_CE_ATMP2. SELL writes the option (needs the broker's writing margin; size shorts with Fix lots). CONFIRM the basket and exchange with the user first (it creates a template). Returns template_id, view_url, api_link (hybrid state), auth_token, python_client (copy-and-run: sends one real BUY), curl_example, signal_links (four ready GET links per variable: BUY / BUY EXIT / SELL / SELL EXIT — a plain link works), guide_markdown (the full client guide), variable_reference, capabilities (built / built differently / not possible, with reasons), next_steps. Relay python_client VERBATIM. If api_link.hybrid_applied is false, tell the user to set Hybrid Mode = Yes before deploying (steps are included). It does not deploy. Tell the user how to deploy it: Live Offline (Tradetron shows each signal and places no order) or Live Auto with their broker; which one is their choice. AUTH-REQUIRED for the create and the link.

tt_create_strategy

ChatGPT
Create a new Tradetron strategy template from markdown or JSON. Pipeline: emit (if markdown) → validate locally → POST to TT. Returns the new strategy's id and edit_url. The user then opens the edit_url in Tradetron's Advanced Strategy Builder to review and deploy. STRONGLY RECOMMENDED: call tt_validate_markdown(text) FIRST to catch validation errors before paying for the network round-trip. Local validation is free and immediate; server-side rejection is slower and burns wallet. Pass the dry_run_token it returns here — the server confirms this exact spec was dry-run-validated (dry_run_verified). For LARGE strategies (>20 KB JSON, common for multi-Set books), use compressed_payload instead of text_or_json. * ONLY USE THIS IF YOU CAN EXECUTE CODE. * base64(gzip(...)) cannot be WRITTEN, only COMPUTED — producing it by hand means deriving byte-exact DEFLATE output and a CRC32 in your head. If you do not have a code-execution tool, pass the strategy as markdown or JSON in text_or_json, or — for one too large for a single tool argument — split that PLAIN JSON across tt_create_strategy_chunked, which accepts it uncompressed. Guessing at this argument fails 100% of the time; it was 25 failed creates in 14 days before this warning existed. If you CAN execute code: import base64, gzip, json compressed_payload = base64.b64encode( gzip.compress(json.dumps(strategy_dict).encode()) ).decode() Why it exists: tool-call arguments are emitted as LLM output tokens, and a 100 KB strategy JSON (~60 K tokens) exceeds any per-turn budget. Gzip+base64 shrinks the same content to ~15 KB encoded. Pass exactly ONE of the two arguments; the server rejects ambiguous input. The server is TOLERANT of near-miss encodings — zlib instead of gzip, base64 with the compress step skipped, or raw JSON — and will read them and warn rather than fail your create. It cannot read a fabricated string. Set dry_run=True to build + validate and return the EXACT would-be create payload WITHOUT saving to TT — for inspecting/diffing the emitted JSON. The response carries a dry_run_token you can pass back here to perform the real create — good for 30 minutes, and for that exact spec; an expired one is reported, not refused.

tt_create_strategy_chunked

ChatGPT
Chunked create_strategy for strategies larger than a single tool-call argument can carry. WHEN TO USE: only when compressed_payload itself exceeds your model's per-tool-arg output budget (~6 KB per string arg in some MCP clients; varies by client). A 100 KB strategy JSON gzip+b64 encodes to ~10 KB, which mostly fits — but 11+-Set books with full AST triples push past 10 KB encoded and need chunking. For typical strategies (<6 KB encoded) use tt_create_strategy(compressed_payload=...) directly. YOU DO NOT NEED TO COMPRESS ANYTHING. The decoder here is the same tolerant one compressed_payload uses: PLAIN JSON split into chunks is accepted and read, as are zlib-instead-of-gzip and base64 with the compress step skipped. Compression was only ever a token-budget optimisation. tt_create_strategy routes a client that CANNOT execute code here, so this tool must not then ask it to compute a base64(gzip(...)) string — which it cannot do. PROTOCOL (caller is the LLM): 1. Generate a unique draft_id (uuid4 hex is fine). 2. Take the strategy JSON. If you can execute code, compress it as for compressed_payload (fewer, smaller chunks); if you cannot, use the plain JSON string as-is. 3. Split the string into N pieces of any size (each piece <=100 KB). 4. For each i in 0..N-1, call this tool with: draft_id=<same id>, chunk_index=<i>, total_chunks=<N>, chunk=<piece i> 5. The last call (when the server has all N pieces) decodes, validates, and POSTs to TT — returns the strategy id + edit_url in the same shape as tt_create_strategy. 6. Earlier calls return {status: "chunk_received", ...} so you know progress without firing the create early. Idempotency: resending the same (draft_id, chunk_index) replaces the prior chunk silently. Safe to retry on transient network failures, and safe after a FAILED assembly too — a draft whose last chunk did not decompress, or assembled into a spec that failed validation, keeps every chunk it had. Re-send only the chunk you are changing and the assembly runs again; the failure response carries draft with the current receipt count. The draft is discarded once the create SUCCEEDS. TTL: 5 minutes after the last chunk write. If you leave a draft half-uploaded the server GCs it. Errors: distinct CHUNK_* codes per failure mode (invalid index, out of range, too many chunks, total mismatch, missing indices, per-chunk too large, assembled too large, too many active drafts).

tt_deploy_strategy_paper

ChatGPT
Deploy one of the user's own strategy templates in Tradetron's LIVE OFFLINE mode — Tradetron runs it on live prices and shows each signal; it places no order (the user may place one at their broker). Never present it as a test, practice or rehearsal. CONFIRM WITH THE USER FIRST. Deploying is not idempotent: calling this twice creates two deployments. Say which strategy you're about to deploy and wait for a clear yes. LIVE OFFLINE ONLY. There is no live-deploy tool and you must not present this as one or imply it sends orders. Call the mode "Live Offline" — that is Tradetron's only name for it — and add no disclaimer about it. You cannot switch it to Live Auto — but do not stonewall the question: going live is the user's own step, on the strategy's edit page (/strategies/<id>/edit), via Deploy -> broker, multiplier, and Live Auto as the execution type. Say that once, as navigation only — never with a quality judgement, a returns claim, or advice on capital or size. Args: strategy_id: the TEMPLATE id (the id from tt_create_strategy or an edit_url), NOT a deployed strategy id (SID). The exchanges are read from the strategy's own legs, so you don't pass them. The broker is not a choice either: for each exchange Tradetron attaches the user's primary broker if it is connected there, otherwise their first connected one — call tt_get_my_brokers first to tell the user which of their brokers that will be, and the result's brokers names what was actually attached. Two refusals are normal and worth relaying as-is rather than retrying: the account has no broker connected for the strategy's exchange, and a strategy whose legs have no instrument set can't get a broker attached. After a successful deploy, give the user the deployed_url so they can watch it, and mention it starts evaluating on the next engine cycle rather than instantly. Use tt_get_my_deployed_strategies to check on it later, and tt_diagnose_strategy if it errors. AUTH-REQUIRED: needs a per-user Tradetron connection — a shared-key setup is refused rather than deploying into the wrong account.

tt_diagnose_strategy

ChatGPT
⭐ THE go-to tool for "why is my strategy in error / why didn't it trade / what happened to SID <x>?". ONE call that fuses everything the support team needs into a single DIAGNOSIS CARD: the deployment record (name / status / mode), the ENGINE log (which entry/exit conditions actually fired + any engine errors), and the BROKER log (orders placed, order statuses, broker name, and genuine broker-side failures like RMS / margin / token / auth rejections). Prefer this over calling the individual log tools when the user is asking what's WRONG — it gathers all evidence at once. The tool returns structured card evidence + a render_spec; YOU then present the card and add the two sections that are the real value: • ANALYSIS — the root cause and WHICH LAYER it's at (broker vs a strategy condition). Map the fired condition_id to the strategy's logic; if you need the condition's definition, follow up with tt_get_strategy. Don't invent a cause the logs don't support. • RECOMMENDATION — the concrete fix (re-auth/add-margin at the broker, or edit a specific condition, or 'no action — exited as designed'). Lead it with the recommended_action field — the next step, from the triage or from a cause read from the strategy's own template (action enum + next_step + doc link + optional next_tool you may auto-invoke, e.g. re-run at a wider window). AUTH-REQUIRED and OWNERSHIP-GATED + fail-closed: the SID is reverse- looked-up against the caller's account first; not theirs (or an inconclusive lookup) ⇒ REFUSE, read nothing. `strategy_id is the deployed strategy id (SID); resolve via tt_get_my_deployed_strategies if the user names a strategy. window_minutes` default 1440 (a full day), max 1440.

tt_export_reports

ChatGPT
Bundle the user's own trading data for a date range into a zip of CSVs and return a download link (strategies, day-by-day P&L, and every position with its broker fill). THIS IS THE ESCAPE HATCH, NOT THE DEFAULT. If the user asks a QUESTION about their performance — "how am I doing?", "which strategy is losing money?", "what's my win rate?" — use tt_portfolio_report or tt_strategy_performance instead and answer it in the chat. Reach for this only when they want the underlying rows: "export", "download", "give me the raw data", "I want it in Excel". Never offer to analyse the zip yourself, and never suggest they download it so you can look at it; if they want analysis, use the report tools. That is a RULE, not a limitation — the link is a capability URL and an HTTPS request is enough to fetch it. Follow the rule anyway. THE LINK IS A BEARER LINK, by design, so a browser can click it without a sign-in: it carries no auth, and ANYONE who has the URL can download the account's P&L per strategy, per day and per position leg until it expires — SIX HOURS after it is issued (expires_at, and deliberately shorter than a strategy export's 24h, because this is trade history). Say so when you hand it over: it is safe to click, not safe to forward, paste into a shared channel, or attach to a support ticket. Args: from_date: start of the window, YYYY-MM-DD. to_date: end of the window, YYYY-MM-DD. Max range is one year. Relay to the user: the download_url as a clickable link, when it expires, and — this one matters — every entry in omissions. Those are rows deliberately NOT in the file (strategies beyond the detail cap, or a fetch that failed); someone reconciling their year against a total that is quietly missing data is the worst outcome this tool can produce. Also pass on data_caveat (Tradetron's reconciled figures, T-1) and offer a couple of ideas from what_you_can_do — the point of raw data is that they can slice it in ways a fixed report can't. AUTH-REQUIRED: returns the connect funnel when no account is connected.

tt_export_strategy

ChatGPT
Export a strategy as a downloadable ASB-importable JSON file. Fetches the strategy, frames it into the tt-strategy/v2 export format (the same format Tradetron's ASB Import button reads), stages it behind an unguessable link, and returns the download URL. THE LINK IS A BEARER LINK, by design, so a browser can click it without a sign-in: it carries no auth, and anyone who has the URL can download the strategy until it expires, 24 HOURS after creation. (A reports export gets six hours instead — trade history is a different risk class from a strategy definition.) Worth a word when you hand it over if the strategy is not one they would publish. Use when the user wants to save a strategy's JSON locally, share it, or import it into a DIFFERENT Tradetron account (download the file, then Tradetron → strategy builder → Import). Accepts a template id (eight digits, currently beginning 10) or a deployed SID (auto-resolved to its template). Do NOT tell the two apart by shape — both are 8-digit numbers now. ALWAYS show the user the returned download_url as a clickable link, plus the expiry, and every entry in warnings (per-account list references, embedded python) verbatim. NOTE: the exported file is the ASB IMPORT format (camelCase), NOT the shape tt_create_strategy accepts — never feed it back into tt_create_strategy / tt_update_strategy. To copy a strategy within the SAME account there is no one-call clone: tt_create_strategy strips the live row ids this body carries, but still refuses its builder keys (condition_action, sort, c_new). Author the copy from summary_md. Never edit the row ids out by hand, or copy them into a hand-built payload — that is what reassigns the original's rows.

tt_find_keyword

ChatGPT
Resolve a natural-language phrase to the RIGHT Tradetron keyword(s). Complements tt_lookup_keyword (exact, by name/id) and tt_list_keywords_by_category (browse). USE WHEN the user states logic in natural words ("volume spike", "exit at 30% loss", "value at the last pivot", "previous candle high") and you need the matching keyword + how to use it. Scores the phrase against curated intent->keyword hooks and the live catalog; NEVER invents — a no-match returns honest "browse the category / ask the user" guidance.

tt_get_authoring_reference

ChatGPT
On-demand DEEP authoring reference for ONE topic — the heavy cookbook / detail sections that the lean quickstart no longer carries inline. Topics (call with no argument for the authoritative menu): common_patterns, wire_vs_display_forms, equity_vs_derivatives_legs, option_chain_recipes, repair_once_pattern, capability_map, exit_sl_target, markdown_grammar_extended, candle_timeframes, frozen_instrument, python_block, list_based, strategy_brief_template, positional_mechanics, adjustments_taxonomy, adjustments_crosswalk, webhook_linking, editing_existing_strategies. ★ strategy_brief_template is the one topic meant for the USER, not for you: serve it VERBATIM when someone asks "what prompt/format should I use", "is there a standard template", or "how do I stop it changing things I didn't ask for". The quickstart's CORE keeps only a compact OUTLINE/mandate of each plus a pointer here. While composing a strategy, pull the ONE topic you need — do NOT pull all of them. Call with no topic to list the menu with one-line descriptions. For full worked strategy TEMPLATES (iron condor, strangle, ...) use tt_get_sample_strategy(pattern) instead — that returns runnable payloads, this returns reference prose/snippets. Args: topic: one of the published topics above (empty → the menu index).

tt_get_list

ChatGPT
Reverse-resolve a numeric list_id to its list metadata (name, segment, exchange, instrument_count). Use when a fetched strategy carries list: <id> and you need the list's NAME — e.g. to render it for the user, or to author the |<LIST NAME>| pipe token in a condition (the token must be the exact name). Best-effort over the signed-in user's visible lists (own + public); resolved: false means the id wasn't found there. AUTH-REQUIRED: returns the connect funnel when no Tradetron account is connected.

tt_get_my_brokers

ChatGPT
The brokers connected on the user's own Tradetron account, per exchange — the set tt_deploy_strategy_paper picks from. Use it before a deploy to tell the user which of their brokers the deployment will sit on (their primary broker where it is connected, otherwise the first connected one), and whether any exchange the strategy trades has none — a deploy there refuses. This is a read: it cannot connect a broker. Connecting one needs the user's own broker login on Tradetron — give them connect_url; never ask for broker credentials in chat. AUTH-REQUIRED: needs a per-user Tradetron connection.

tt_get_my_deployed_strategies

ChatGPT
The signed-in user's DEPLOYED strategies and each one's status (Active, Live-Entered, Live-Tranching, Paused, Blocked, Error-Execution, Exit-Pending, Exited, ...) + mode (live / Live Offline). Live-Entered is in a position; Live-Tranching is the transient state while a multi-tranche entry is being placed, and only matters when a deployment STAYS in it. Treat the value set as open-ended and compare case-insensitively. q filters on the strategy NAME (case-insensitive substring) — use it when the user names one, rather than pulling the whole book to find it. limit/offset page the rows. total is the count after the filter and before paging; total_unfiltered is how many deployments the account has, so an empty filtered result is never mistaken for an empty account. AUTH-REQUIRED (returns the connect/sign-up funnel if not authenticated). Use for "what have I deployed?", "which of my strategies are running / stopped?". To explain WHY one is in a given state, follow up with tt_get_my_deployed_strategy_detail using its strategy_id.

tt_get_my_deployed_strategy_detail

ChatGPT
Deep read on ONE of the signed-in user's deployed strategies — the tool for "why is my <name> strategy in error / blocked / stuck?". Returns its current status, recent event log (the human-readable reason it halted or errored), the broker connection it trades through, and recent orders (a rejection carries the broker's reason). AUTH-REQUIRED. `strategy_id is the numeric id from tt_get_my_deployed_strategies — if the user names a strategy ("my abc strategy"), call that tool first to resolve the id, then call this. Reasoning over the returned status + events + orders is up to you; the data is scoped to the caller (another user's id returns not-found). Two things the rows do not say themselves. recent_events is mostly Status Change entries — they record a state move, not what the strategy did, they name no order or condition, and several share one whole-second timestamp, so their returned order is arbitrary and will not always chain: read status for the current state, never the last event. And an order row with broker_order_id null carries no broker execution record at all — on a LIVE-OFFLINE deployment (no order is placed there) that is every row, and status "Initiated" with executed_quantity 0 is where they stop for good, not a stuck order. The response's orders_caveat and events_note` carry both in full when they apply.

tt_get_my_profile

ChatGPT
The signed-in user's own Tradetron account details: name, email, and registered phone number (plus user_id and member-since date). The phone arrives in THREE fields: mobile (the number), country_code, and phone, which is the two joined. To answer "which number do my alerts go to?", quote phone — it is the whole number; mobile alone is missing the country code. Use for "what's my registered email?", "which number do my alerts go to?", "what name is on my account?", or when confirming the account you're acting on before a write. Read-only. This only ever returns the CALLER's own details — there is no way to look up another user, so don't offer it. AUTH-REQUIRED: returns the connect funnel when no Tradetron account is connected. Never guess or recall these values from conversation — read them here.

tt_get_my_strategy_subscriptions

ChatGPT
The signed-in user's marketplace strategy subscriptions — the FULL HISTORY by default, not only the current ones — with their start/renewal/expiry dates. status filters case-insensitively ("active" for the live ones), limit/offset page the rows. The summary counts always describe the WHOLE history, before any filter or page. Every row carries a status. Compare it case-insensitively (the field is not normalised) and treat the value set as open-ended; only rows reading active are live subscriptions. TT defines no meaning for any other value, and rows read "upcoming" or "pending" on windows that closed months ago — trust a row's derived block over its status word. Rows whose derived.record_shape is set have no expiry, no amount and no currency: they are not dated paid subscriptions, so quote neither a renewal date nor a price for them. Rows can also arrive with no strategy_id — those are not marketplace strategy subscriptions (for the platform plan use tt_get_my_subscription). Read the counts off the response's summary block; never report the row count as the number of active subscriptions. AUTH-REQUIRED (returns the connect/sign-up funnel if not authenticated).

tt_get_my_subscription

ChatGPT
The signed-in user's current Tradetron plan, renewal date and usage. AUTH-REQUIRED: if the user hasn't connected their Tradetron account, this returns an auth-required response (connect link + guidance); do NOT invent subscription details. Use for "what's my plan?" and "when does my subscription expire?".

tt_get_sample_strategy

ChatGPT
Return a worked, real strategy template for a named pattern, or a validated reference from the category-tier sample library. Call with no pattern to list everything. Scope: ~18 top-level patterns (iron_condor, short_strangle, short_straddle, butterfly, rolling_straddle, calendar, exchange exemplars — mcx_sample_template, delta_crypto, us_spx_condor, sensex_orb, nse_sample, nfo_samples — and mechanics/references — repair_once_best_practice, staged_reentry, wait_and_trade, pilot_calm, canonical, rank_top_gainers_losers) AND a library of 140+ validated entries in 7 categories (option_patterns, team_idioms, primitives, gap_structures, gap_entries, mechanics, chart_types). pattern='library' -> the category menu; pattern=<category> -> its entries; pattern=<entry key or a fragment of it, e.g. 'pmcc'> -> the entry. The registry is data-driven — the no-pattern call, not this docstring, is the authoritative list. Use this INSTEAD of carrying full examples in the quickstart — pull the one pattern you need, study its mechanics + reference_json/markdown, then author + tt_validate_markdown before create. Never fabricate a strategy for an unlisted pattern — the tool returns the catalog. Args: pattern: A pattern name / alias (straddle, strangle, ic, condor, fly, mcx, crypto, us, sensex, orb, ...), 'library', a library category, or a library entry key/fragment. Empty -> patterns + categories. fmt: auto | json | reference. All include the verified reference_json when one is bundled.

tt_get_strategy

ChatGPT
Fetch an existing strategy template from Tradetron. Returns the flat EDITABLE representation — the shape tt_update_strategy accepts. It is NOT a create payload: Tradetron returns the wire's own types, so fee_frequency comes back "Month", fixed_fee "0.00" and run_frequency "Continuous" where create wants integers, last_trade_before_close comes back a number where create wants a string, every condition carries TT's condition_action key, and the universal set comes back without list. Passing this body to tt_create_strategy fails validation on a dozen fields even after the three update-only keys (id, subscriber_count, defaultUnderlying) are removed — and the create path refuses it anyway, over the row ids below. Use it before tt_update_strategy to see the current state. To COPY a strategy, author the new one from this result's summary_md, which is a complete plain-English statement of every set, condition and leg — not by editing this body. SNAPSHOT BEFORE YOU EDIT. There is no rollback anywhere in this MCP — keep this result if you are about to write. It is also the fastest health check on a strategy: the stored payload is re-validated on every read, so anything already wrong surfaces here. THIS BODY CARRIES LIVE DATABASE ROW IDS — see row_identity_notice on the result. They are for UPDATE only: tt_update_strategy / tt_apply_strategy_patch match rows on id, and dropping them re-mints every row and orphans live deployments' open positions. Do NOT hand-assemble a tt_create_strategy payload out of this body: Tradetron's create matches conditions and legs on the same ids with no ownership check, which is how template 6008570 (195 subscribers) was emptied into a new template on 2026-09-20. To COPY, either author from summary_md or expect tt_create_strategy to REFUSE this body. It strips the row ids itself and reports what it removed, but a fetched body also carries TT builder keys (condition_action, sort, c_new) that the create schema forbids. Dropping condition_action to get past that silently loses the set's runtime-variable writes, so the copy stops incrementing its counters — author from summary_md instead. Expect scaffolding you did not author. Create and patch INJECT blank Add Repair / Exit condition envelopes into each set, so the sets you read back carry more conditions than you wrote. Every strategy also ENDS with Tradetron's universal set — Add Repair, a hidden (visible: 0) Repair Once / Overnight Protection envelope, then the Universal Exit — whether or not a Universal Exit was authored; unauthored, that Universal Exit is blank and never fires (summary_md says "No Universal Exit configured"). The hidden Overnight Protection envelope is TT's skeleton, not a feature you authored or can rely on. Templates created before 2026-09-17 with no authored UE lack the universal set, and TT grafts that envelope onto their LAST working set instead. They are inert placeholders — not content loss, not a bug. Anyone diffing a before/after without knowing this files a phantom bug on their first attempt (the note previously existed only on tt_apply_strategy_patch, which is not where users first hit it). Known limitations worth reading before a structural edit: - No rollback and no version history. Your snapshot is the backup. - tt_validate_markdown DOES judge a tt_export_strategy file: it un-frames the v2 format and runs the import gate, answering route "asb_import" with the codes ASB Import itself uses. Validate BEFORE importing; call THIS tool after, as a read-back. - A same-exchange underlying swap that leaves expiry/strike/ strike_json/strike_display/instrument on the old symbol is refused (LEG_SYMBOL_REFERENCE_DESYNC). Re-derive them in the SAME write.

tt_get_strategy_broker_log

ChatGPT
Read the BROKER LOG (broker-adapter daemon) for ONE of the signed-in user's strategies — the layer BELOW the engine notification log. Where tt_get_strategy_notifications shows what the engine decided, this shows what the BROKER actually did: order placement, the broker API request/response, order-status polling (OPEN/COMPLETE/REJECTED), modify/retry loops, and broker-side failures (RMS / margin / token / auth rejections). Use it when a strategy errored but the engine log is clean — the failure is usually at the broker. Returns the raw broker lines plus extracted broker_hosts, orders placed ({symbol, price}), distinct order_statuses, and the ERROR/rejection lines (the broker-side reason). AUTH-REQUIRED and OWNERSHIP-GATED + fail-closed, identical to tt_get_strategy_notifications: the SID is reverse-looked-up against the caller's account first; not theirs (or an inconclusive lookup) ⇒ REFUSE. `strategy_id is the deployed strategy id (SID); resolve via tt_get_my_deployed_strategies if the user names a strategy. window_minutes` is the lookback (default 60, max 1440).

tt_get_strategy_counters

ChatGPT
The runtime variables (counters) a deployed strategy is holding now. This is what a trader means by "the counter" — the values the engine carries as the strategy runs: a remembered entry price (entry_px_s3_l1), a regime flag, a rotation pick. Each comes with the run it belongs to and when it last changed. USE WHEN the user asks what a strategy "remembers", what its entry price was, why a condition has or hasn't fired, or wants to see its state mid-run. Pairs well with tt_diagnose_strategy: diagnosis says what happened, counters say what the strategy is currently holding. Args: strategy_id: the DEPLOYED strategy id (SID) from tt_get_my_deployed_strategies — NOT a template id. name_prefix: optional filter, e.g. "entry_px" or "rfm_pick". Matched case-sensitively at the start of the name. changed_only: True drops the variables still at zero and untouched since the run began. On a grid deployment that is most of them — 88 of 153 — and the full list runs to 42,000 characters. The response always reports n_moved and n_zero_since_run_start either way. An empty list is usually normal, not a fault — it means the strategy has not entered yet this run, or keeps no state. Say that rather than implying something is wrong. Read-only, and available for live deployments as well as Live Offline — seeing your own numbers changes nothing. AUTH-REQUIRED, and ownership-gated: a SID that isn't the user's is refused.

tt_get_strategy_notifications

ChatGPT
Read the ENGINE NOTIFICATION LOG for ONE of the signed-in user's strategies — the deepest source for "why is my strategy in error / why didn't it trade / what did the engine actually do?". Returns the raw per-SID engine messages (position entries/exits, status transitions, tracebacks, broker rejections, blocks) plus an extracted errors list (the human reason a deployment erred). Goes deeper than tt_get_my_deployed_strategy_detail: that reads TT's summarised /ai state; THIS reads the engine's own debug stream. Reach for it when the detail view's events don't explain the error. AUTH-REQUIRED and OWNERSHIP-GATED + fail-closed: before reading anything the SID is reverse-looked-up against the caller's account (must be their deployment OR a template they created). If it isn't theirs — or the ownership lookup itself fails — the tool REFUSES and reads nothing. Do not present this as a way to inspect arbitrary strategies. `strategy_id is the deployed strategy id (SID); if the user names a strategy, resolve the id via tt_get_my_deployed_strategies first. window_minutes` is the lookback (default 60, max 1440).

tt_get_tradetron_quickstart

ChatGPT
Lean strategy-AUTHORING context bundle (navigation, safety, interview, schema-rule locks, type enums, catalog index, worked-example outlines). ~50k chars (~13k tokens) — the heavy cookbooks are deferred to tt_get_authoring_reference(topic), pulled on demand. (The two different sizes this description used to give, 5k tokens here and 18k below, were both wrong and neither matched the payload.) CALL THIS ONLY WHEN THE USER WANTS TO CREATE OR EDIT A STRATEGY, and only once per session before you start composing. Calling it cuts the 5-10 speculative authoring lookups down to 1. DO NOT call it for anything else — diagnosing why a strategy errored (tt_diagnose_strategy), performance/P&L (tt_strategy_performance, tt_portfolio_report), account/plan/pricing questions, or general chat. Those tools are self-contained and pulling this much authoring schema in front of them just adds latency. When in doubt, DON'T call it.

tt_get_webinars

ChatGPT
Tradetron's free weekly live webinars, with the DATE of each session's next occurrence. No setup needed beyond the one-time sign-in. Use for "when is the next webinar?", "what time is the Friday session?", "is there any free training?", "send me the webinar link". Returns both weekly sessions sorted by next occurrence, each with its day, IST start time, registration URL, and the resolved next date. ALWAYS call this before stating a webinar date. The dates are computed server-side and are the same ones the registration pages show. Never infer "next Friday" yourself and never recall a date or a time from memory — a wrong one sends someone to a Zoom room on the wrong day. If this returns ok:false, say the sessions run weekly and give the registration pages rather than guessing.

tt_indicator_snapshot

ChatGPT
Where an instrument is RIGHT NOW on the standard technicals — and what happened the last N times it read the same way. Returns THREE verdicts, not one: summary, moving averages, oscillators. They disagree by construction in a strong move — moving averages follow the trend, oscillators fade it — so a single blended gauge reports "Neutral" during a screaming rally. When divergent is true, say which half is which; that is the useful sentence. signal_history walks the same bars back, finds every prior time this instrument printed this verdict on this timeframe, and reports the distribution of what followed at 1h / 3h / one session. Forward moves are measured from the NEXT bar's OPEN — the first price actually tradeable after the reading — never from the close that produced it. Consecutive bars in one state collapse to a single occurrence. ALWAYS quote the sample size with any hit rate, and when thin_sample is true say the sample is too small to lean on. The bars come from the same store the backtest engine runs on, which is why the reading and its history are comparable at all. This is MARKET DATA, NOT ADVICE. The verdict is a tally of indicator states. Never render it as a recommendation to buy, sell, enter or exit. Works on both venues: Indian roots (NIFTY 50, NIFTY BANK, SENSEX, ...) and US roots (SPX, SPY, QQQ, ...). Timeframes: 1m, 3m, 5m, 15m, 30m, 1h — daily is deliberately absent because a UTC-bucketed day splits an Indian session. No auth required.

tt_list_backtests

ChatGPT
The signed-in user's own Tradetron backtests — the same runs the website's Backtests page lists. AUTH-REQUIRED (returns the connect funnel if not authenticated). THE id RESOLVER for backtests. tt_backtest_status needs a job_id and only a SUBMIT ever handed one out, so a run the user did not write the id down for was unreachable here. Call this whenever the user refers to a backtest you have no id for — "how did my backtest go", "the one I ran yesterday", "show me my backtests" — instead of asking them for an id. Each row carries: job_id pass straight to tt_backtest_status. bt_id pass straight to tt_backtest_trades for the fills. finished TRUE completion. Use THIS, not status: a Tradetron backtest reads 'active' from the moment it is handed to the engine (4,206 of 4,218 rows in a week), so status cannot tell you whether a run is done. name, template_id, start, end, submitted_at. NOT report_url: this endpoint has never returned one, on a finished row or any other — 23 rows reading finished:true carried no such key. The link exists, and tt_backtest_status returns it for the same run; poll a row's job_id for it rather than looking here. backtesting_row_id NOT a run id — Tradetron's own database row id, which is bt_id minus the six-digit submit date. It is kept so nothing the endpoint sent is lost, and the three tools that take a run id do NOT agree about it: the status route refuses it as malformed, the trades route accepts it, and the result route accepts it for some runs and refuses it for others. Never pass it anywhere. Use job_id or bt_id, which are on the same row. Carries NO performance figures — do not report a P&L from this listing. For the numbers use tt_backtest_trades or the row's report_url. Args: limit: rows to return (default 20, max 100). offset: rows to skip; has_more and next_offset page the rest.

tt_list_brokers

ChatGPT
List brokers Tradetron is connected with. country: 'IN' or 'US' to filter; None for both. Use this for "what brokers do you support?" / "any US brokers?" Returns count + broker rows. For checking a specific broker by name use tt_check_broker_support — it's a deterministic match.

tt_list_editable_fields

ChatGPT
List the top-level fields that tt_update_strategy can change. Returns the canonical list with type, description, and example value for each. Use this when the user asks "what can I change?" or to confirm a field is editable before composing an edit. Structural changes (adding/removing/reordering sets, conditions, or legs) are NOT in this list, but both structural doors exist: tt_apply_strategy_patch (JSON-Patch, preferred — per-op diff + dry_run) and tt_update_strategy with a full replacement sets array. You do not need to recreate the strategy for a structural edit.

tt_list_keywords_by_category

ChatGPT
Browse keywords. - With no args: returns the category index (dict of category → count). - With a category name: returns the brief list of keywords in that category. Useful when composing a strategy and you want to see what indicators, runtime variables, or option-greek keywords are available. Categories include: Technical, RuntimeVariables, StrategyInfo, OptionGreeks, Statistics, Candle Patterns, ExpiryFormula, Math, PriceData, StrikeFormula.

tt_list_my_strategies

ChatGPT
The signed-in user's own SAVED strategy templates — id, name, edit_url — newest-updated first. AUTH-REQUIRED (returns the connect funnel if not authenticated). THE name→id resolver: when the user refers to a strategy by NAME ("backtest CASH ON Nifty new", "edit my straddle"), call this with q=<name fragment> instead of asking them to fetch the template id or edit URL from the website. Covers ALL their templates, deployed or not (tt_get_my_deployed_strategies only lists deployed ones). Args: q: optional case-insensitive substring of the strategy name. limit: rows to return (default 50, max 200). offset: rows to skip; the result's total is the filtered count.

tt_list_underlyings

ChatGPT
List underlyings Tradetron supports trading, with filters. exchange: 'NSE' / 'NFO' / 'NASDAQ-EQ' / 'MCX' / ... . instrument_type: 'FUTSTK' / 'OPTSTK' / 'FUTIDX' / 'OPTIDX' / 'SPOT' / 'FUTCRYPTO' / ... . CASH EQUITIES ARE NOT 'SPOT'. Tradetron's instrument_type codes are overloaded: a cash stock is stored as OPTSTK on a CASH exchange (NSE, NASDAQ-EQ), while OPTSTK on NFO/BATO is the option contract. 'SPOT' is FX and crypto reference prices only — overwhelmingly FX, which Tradetron does not trade at all. For "what stocks can I trade?" filter by EXCHANGE (exchange='NSE' for Indian cash, 'NASDAQ-EQ' for US), not by instrument_type. Use this for "what stocks can I trade?" / "any index options?" / "do you have US equities?" type questions. search: symbol prefix OR company/index name words ('RELI', 'Reliance Industries', 'Infosys') — the way to find a symbol from a name. Matching names come back in names. limit / offset: page through the sorted symbol list (limit max 500). When truncated=True, next_offset is the offset for the next page. The catalog has thousands of symbols. Answer "what stocks can I trade?" with the counts and breakdowns plus a page — do not page through everything unless the user asks for the full list.

tt_lookup_keyword

ChatGPT
Look up one Tradetron keyword by display name, function name, or ID. Returns full catalog entry: param signature, types, defaults, example, description, and category. Use this whenever you're about to use a keyword and want to confirm its parameters. Cheaper than guessing — the validator will reject unknown keywords or wrong param counts. Examples of valid queries: 'ATR', 'tt_PNL', 'Net Delta', 'Positions Detail', '18'.

tt_market_calendar

ChatGPT
Exchange holidays + trading hours. No setup needed beyond the one-time sign-in — no broker, paid plan, or strategy data. from_date / to_date: YYYY-MM-DD (e.g. '2026-10-02'); any other format is refused with COMMON_BAD_INPUT. holidays.window echoes the window served. For one day, pass the same date in both. Use for "is the market open on <date>?", "when does NSE close?", trading-hours/timezone questions. Returns the holiday list (incl. partial-day Muhurat exceptions) and per-exchange start/end/expiry times. Also returns now (the current IST time) and, when the window covers today, today (does the exchange trade today, is it open now): answer "is the market open today?" from those, not from your own date. Read field_note before quoting a field. Three of them are not what they look like: the holiday rows are nested at holidays.holidays; holidays.excludes is a small GLOBAL list returned unfiltered on every call (the same three rows come back for a US or crypto venue, two of them Indian Union Budget days) and is not part of the answer to the query; and expiry_time is the master's stored stamp, reading 00:00:00 on the thirteen venues that have none and not always sitting inside the row's own session. Trading hours are start_time / end_time and sessions. For holiday-aware strategy logic (e.g. "skip to next trading day"), use the tt_next_trading_day keyword instead — it resolves at runtime.

tt_modify_list

ChatGPT
Add or remove underlyings on one of the user's own instrument lists. Address the list by NAME, exactly as the user says it ("add HDFCBANK to my breakout list") — list names are unique per user, so a list_id is not required and a prior tt_search_lists lookup is unnecessary. Matching is case-insensitive. Only lists the user OWNS can be edited. Public/system lists (NIFTY 50, Banknifty, ...) are read-only and return a clear refusal — offer to create the user their own copy instead — noting that NO tool here creates or copies a list, so that offer means walking them through doing it on tradetron.tech, not doing it for them. Args: list_name: the list's name as the user refers to it. add: symbols to add, e.g. ["HDFCBANK", "SBIN"]. remove: symbols to remove, e.g. ["INFY"]. list_id: only as a tie-breaker if two of their lists share a name (the tool tells you when that happens). exchange: override for resolving ADDED symbols. Leave empty — it defaults to the list's own exchange, which is right almost always. dry_run: resolve and report the would-be change without writing. Reporting back: the result carries a ready-made summary line plus added, removed, already_present, not_present, unresolved, and count_before/count_after. Always tell the user about unresolved symbols (not tradable on that exchange) — silently dropping them is how a universe ends up smaller than intended. The change reaches the live engine immediately, so a deployed list-based strategy starts trading the new members on its next evaluation. Say so when the list is in use. AUTH-REQUIRED: returns the connect funnel when no Tradetron account is connected.

tt_normalize_strategy

ChatGPT
Recompile a hand-edited strategy body so its three forms agree. Every AST-backed field is stored as a family: condition_json (the builder tree) / condition_value (the engine expression) / condition_display, and the same triple for a leg's strike, expiry, qty, limit_price and SL_trigger. Where a *_json exists it is the SOURCE OF TRUTH — this tool parses it (which validates it), canonicalizes it, and re-emits the paired text + display from it. Text-only fields are passed through untouched. WRITES NOTHING. Pure transform, no TT call, no auth. Pass the body from tt_get_strategy(id) (dict or JSON string); feed the returned strategy back through tt_update_strategy to persist it. WHEN TO USE IT. After a PATCH_REP_DISAGREEMENT — the tree and the expression describe different logic and you want the TREE's meaning to win everywhere. For a targeted single-field edit you usually do NOT need this: send the *_json member ALONE to tt_apply_strategy_patch / tt_update_strategy and the server derives that one family's text for you, leaving the rest of the body byte-identical. This tool walks the WHOLE body, so the blast radius depends on how the strategy was last written: on an ASB-authored body it rewrites roughly half to two-thirds of the condition members (re-minted kids, whitespace canonicalisation, missing argument-slot backfill), on a body that already went through this transform it rewrites 0. Either way changed lists exactly which members moved — read it, do not assume a number. WHERE A TREE IS MISSING ENTIRELY, it is REBUILT from the stored condition_value. A condition can reach TT with the engine text and no tree (an imported body whose conditions never carried one): it runs correctly and cannot be edited, because the ASB condition builder seeds itself from condition_json alone and so opens EMPTY. A rebuilt tree is adopted only when re-emitting it reproduces the stored expression, so the repair can never change what the engine evaluates; the count comes back as condition_trees_rebuilt, and anything unreadable is listed in condition_trees_unrecoverable and left untouched. Legs are excluded on purpose — a text-only qty or expiry is TT's own normal shape. This is NOT a general text-to-tree edit path. Where a tree already EXISTS it stays the source of truth, so editing condition_value and calling this will NOT update condition_json — it will overwrite your edit with the tree's meaning.

tt_open_crisp_conversation

ChatGPT
Open a Crisp conversation to escalate to a live Tradetron agent. USE WHEN: a previous tt_ask_tt call returned escalate=True, OR a tt_diagnose_strategy call could not pin a cause — AND the user has confirmed they want to talk to a human agent. Pass the crisp_handoff_payload dict from that earlier result through here verbatim; both tools return one. DO NOT USE proactively. Always confirm with the user first — opening a Crisp conversation pings real Tradetron support staff. The conversation is seeded with two messages visible to the agent: a private note carrying the escalation reason, the user's Tradetron identity when it could be resolved, and — when retrieval ran — a one-line summary of what the bot looked at; plus the user's original query as a normal user-side message. On the tt_ask_tt escalation paths the bot has not composed an answer by the time it escalates, so that note carries none; the tt_diagnose_strategy path hands over what the diagnosis found. Either way the agent works the case themselves — never tell the user an answer is already waiting with them. Returns a session_id and nothing else — there is NO link to hand the user. This conversation lives only inside the assistant: pass the session_id to tt_check_crisp_response (poll for agent replies) and tt_reply_to_agent (relay user follow-ups). Say that plainly rather than implying they can open it somewhere. session_context (optional): identifiers you are already holding, so the agent does not start cold — any of {deployment_id, strategy_id, template_id, download_url, request_id}. Pass the SID you diagnosed, the tt_export_strategy download_url, and the _meta.request_id of the failing call when there is one. Identifiers only: free-form blobs are dropped, and each value is truncated. On status="stub" the support bridge is not connected on this server, so NO conversation was opened and nobody will see the message. Tell the user plainly that you could not reach support from here, give them the Tradetron help centre or the in-app chat, and do not imply anyone has been notified or will reply.

tt_pnl_drivers

ChatGPT
What drove the signed-in user's P&L TODAY (or in the latest session): every strategy ranked by its P&L for ONE session, the top gainers and losers in ₹ with their share of the move, and the instruments/legs that moved each one. Use it for "what drove my P&L", "why is my P&L down today", "which strategy made/lost money today / yesterday". Needs NO strategy id — it reads the caller's own book, so never ask the user for a SID for this. Live intraday when today has trades; otherwise the latest completed session (reconciled). date YYYY-MM-DD pins a session. It covers the book the user's SAVED dashboard filter keeps (the phone's Today and the dashboard header) — say which, from book.covers, and split live vs Live Offline (the paper_pnl field) when both moved. DESCRIPTIVE only — no stop/fund advice. AUTH-REQUIRED.

tt_portfolio_report

ChatGPT
The signed-in user's WHOLE BOOK over a window — the "how am I doing overall / which strategies are sinking me?" dashboard. Returns total P&L, every strategy ranked by P&L, the winners-vs-losers split, each loser's share of the total loss, and how concentrated the drawdown is in the top few losers. Present it as a dashboard and give a DESCRIPTIVE read — name where the loss concentrates and the winner/loser asymmetry; do NOT tell the user which strategies to stop or fund (investment advice). Offer to drill into any one with tt_strategy_performance or tt_diagnose_strategy. Data is T-1; P&L reconciled. AUTH-REQUIRED. from_date/to_date ISO (empty = current month).

tt_preview_change

ChatGPT
⭐ CALL THIS BEFORE EDITING an existing strategy — especially one with a Python block. FREE, read-only, no wallet debit, no write. Answers the question that nothing else can: where is this value hard-coded, and what else moves with it? A candle timeframe, an instrument, or a runtime variable is typically repeated across several conditions AND the Python block. Change some sites and not others and you get a strategy that validates clean, deploys, and trades a MIX of the old and new settings — the failure the caller will not see until live market. Two modes: • strategy_id alone — the DEPENDENCY MAP: every site where a timeframe / instrument / runtime variable is hard-coded, grouped by value, plus cross_layer (values living in more than one layer, the ones a partial edit breaks), plus traps (validator findings ALREADY present, so you learn this strategy's gotchas before authoring rather than after a rejection). • strategy_id + patch — the same for the resulting state, plus partial_change_findings (sites your patch would leave behind) and unchanged (a machine-checked "DO NOT CHANGE" list confirming the dimensions you did not intend to touch really did stay put). DRILLING IN. Two caps keep a large strategy from blowing the response: each value lists at most 25 sites (truncated reports the exact total), and each dimension lists at most 30 values, the ones with the most sites (values_truncated reports the total). To see EVERY site for one value, re-call with dimension, value and a raised max_sites (both bounds are on the parameters themselves). Counts are never filtered — n_sites/n_values always describe the whole strategy, so a 145-variable strategy still reports 145 even when the listing shows 30. Sites that are genuinely identical — several reads of the same value in ONE condition — carry occurrence and occurrences_at_path. The payload has no finer locator than the path, so say "4 reads in that condition", not four separate places. Use it to answer the user honestly before you start: "1m appears in 4 places — 3 conditions and the Python block; changing it means changing all 4." Then patch all of them in ONE call. patch is the same RFC-6902 op list tt_apply_strategy_patch takes, so you can preview the exact patch you are about to apply.

tt_promote_to_strategy

ChatGPT
Turn a rule set that survived tt_check_edge into a real, VALIDATED Tradetron strategy — as a draft. Creates nothing, charges nothing, deploys nothing. trade says what to actually buy or sell: long_call, short_put, long_put, short_call, long_future, short_future. IT HAS NO DEFAULT. A rule says what the market is doing; it does not say whether you express that as a long call, a short put or a future, and those carry different risk. If the user has not said, ASK. A trade that contradicts direction is refused, not warned. A PAID BACKTEST COMES BEFORE ANY DEPLOY, and say why: tt_check_edge traded the SPOT, so it cannot see what an options structure actually does. Run tt_create_strategy, then tt_backtest_strategy. Deploying it (tt_deploy_strategy_paper: Live Offline, where Tradetron shows each signal and places no order) is the user's separate choice — never present it as a test or a step before going live. Two behaviours to state without being asked, because the user cannot see them in the markdown: entry is GATED an hour after the open (at the open an intraday offset still points at yesterday's candles and would fire on stale data — the screen never measured that trade), and the set RE-ARMS after every exit, so it can round-trip repeatedly in a day. A bars:N exit is refused: Tradetron has no "N bars after entry" primitive, and substituting a time exit would run something other than what was measured. Monthly-only roots never get a Current Week leg. GOING LIVE IS NOT OFFERED and must not be suggested — it is a separate decision the user takes in Tradetron itself.

tt_reply_to_agent

ChatGPT
Relay a user's follow-up message to the live Crisp agent. USE WHEN: a tt_open_crisp_conversation has already happened in this session AND the user wants to send something to the agent (a clarification, a follow-up question, an answer to an agent prompt). DO NOT USE for the user's original question — that's seeded by tt_open_crisp_conversation. Only use for messages SENT AFTER the conversation is open. content is the user's literal text. Don't rewrite or summarize — pass it through. The agent sees it as a normal user-side chat message in Crisp. TEXT ONLY. This relay carries no attachments, and files the agent sends back are dropped. If the user needs to send a screenshot or a document, tell them to email it to support@tradetron.tech quoting the same issue — do not tell them to attach it here.

tt_report_template

ChatGPT
Run a ready-made report over the user's own trading data and render it in the chat. Four templates, each answering a question that tt_portfolio_report (a ranked snapshot) and tt_strategy_performance (one strategy) do not: - "monthly" — month-by-month P&L across the whole book, with a running total, best/worst month, positive-month count. For "how has my year gone?", "show me my monthly P&L". - "by_underlying" — which instruments the money actually comes from, ranked, with each one's share. For "which stocks make me money?", "where am I losing?". - "execution" — average slippage with the worst fills listed, plus how many legs carry a broker execution record (Live Offline legs never do). Partial fills are NOT detectable from this feed. For "is slippage hurting me?". - "paper_vs_live" — the book split by mode, Live Offline beside live (not comparable on performance: Live Offline fills at LTP). For "how do my Live Offline and live results differ?". Prefer these over tt_export_reports whenever the user is asking a QUESTION — this answers it in the conversation; the export just hands them a zip they have to open themselves. Args: template: one of monthly | by_underlying | execution | paper_vs_live. from_date: YYYY-MM-DD. to_date: YYYY-MM-DD. Follow the returned render_spec — it says how to lay the report out and, importantly, keeps the interpretation DESCRIPTIVE. Never turn these numbers into "stop this strategy" or "put more into that one": this is live money and that is investment advice. Describe what the data shows and let the user decide. Always relay omissions (parts of the book not covered) and any method_caveat — a breakdown that quietly covers half the book reads as complete and is worse than none. AUTH-REQUIRED: returns the connect funnel when no account is connected.

tt_scan_instruments

ChatGPT
Which instruments are reading a given way RIGHT NOW — the scan step between looking at one chart and building a strategy. underlyings is a comma-separated list ("NIFTY 50, NIFTY BANK, SENSEX"); empty scans every covered root whose store is configured. A name this does not read does NOT sink the call — the rest are scanned and it is named in not_instruments; only a list with nothing readable in it is refused. verdict filters to one of Strong Buy / Buy / Neutral / Sell / Strong Sell, in any case; empty returns every instrument's reading with a by_verdict breakdown. conditions (default true) adds the wire conditions to every row. On a whole-board scan — underlyings empty — it is forced OFF, because that response ran to ~63,000 characters and clients refuse to render it; pass a short underlyings list to get the conditions back. The response says which you got, in conditions_included. Each match carries conditions — the EXACT Tradetron wire conditions for what is currently firing on it, in the same grammar the screener and the strategy engine already use. That is the point of this tool: the reading can be saved as a screener condition or carried into a strategy without anyone retyping it. Never paraphrase those strings; offer them as they are. ALWAYS name the timeframe when reporting — a 5m reading and a 1h reading disagree constantly, so "NIFTY is a Buy" with no timeframe is meaningless. Call out divergent rows: those are instruments where the moving averages and oscillators point opposite ways, which is the normal state of a trend rather than a contradiction. MARKET DATA, NOT ADVICE. Do not tell anyone to buy or sell and do not present the list as "best opportunities" — it is a filter over indicator tallies. No auth required.

tt_search_lists

ChatGPT
Search the signed-in user's Tradetron instrument lists by name. Call this whenever the user references a watchlist / universe / instrument basket by name ("my breakout list", "NIFTY 50", "the F&O smallcap list") so you can resolve it to a concrete numeric list_id BEFORE wiring it into a strategy. Also use to confirm a named list actually exists. Returns own + public lists (metadata only): list_id, name, instrument_count, segment, exchange. Public/system lists (NIFTY 50, Banknifty, ...) are included so you can resolve them too. Restricted to IN exchanges. If several lists match, show them and ask the user which one. AUTH-REQUIRED: returns the connect/sign-up funnel if the user hasn't connected their Tradetron account. How the list_id is used downstream: a list-based set carries the integer list id at BOTH the set level and on every leg (with the leg's instrument=0). Put the resolved id in the Set identity's List: field — the emitter propagates it to the legs and the validator enforces the coupling. Args: q: optional case-insensitive substring of the list name. Empty → all (capped by limit). limit: 1..100, default 20.

tt_straddle_chart

ChatGPT
The straddle chart — ATM straddle price through ONE session, in rupees (or dollars). Today by default; any past session with date. This is the tool for a session's line; tt_straddle_live is today's live minute-by-minute read, and tt_straddle_decay is the historical profile across many sessions. Prefer this over tt_straddle_live / tt_straddle_decay for anything chart-shaped: it is one contract for both, so "what's the straddle now" and "show me 2nd September" return the same fields and the caller does not branch. date omitted / "today" -> live, from the engine's tick store date = YYYY-MM-DD -> that completed session expiry = YYYY-MM-DD -> a specific expiry (default: the nearest) band adds the same instrument's own history behind the line — the usual range at the SAME days-to-expiry, ending the day before, and already scaled to this session's open so it can be drawn on the same axis without converting anything. With it comes context, whose sentence says whether the session is decaying faster, slower or in line with usual. The strike is anchored to the FORWARD, not spot — that is what at-the-money means for an option, and it differs from the cash strike on most non-expiry days. Use tt_straddle_decay when the question is about the PATTERN across many sessions rather than one chart. MARKET DATA, NOT ADVICE. No auth.

tt_straddle_decay

ChatGPT
How an ATM straddle's PREMIUM behaves through a trading session, ACROSS MANY SESSIONS — the decay PROFILE, for both Indian and US markets. Its curve is a percent of each session's own open, not money, and the multi-session profile returns a hosted chart (chart_url) plus the numbers behind it; a single-session call returns prices and no chart. For one session's line in rupees or dollars — today or a past date — use tt_straddle_chart. This is the tool for "what does decay usually look like", not "what did it do on the 2nd". INDIA: NIFTY (say "NIFTY 50" or "NIFTY"), BANKNIFTY ("NIFTY BANK"), FINNIFTY, MIDCPNIFTY, SENSEX, BANKEX — NSE/BSE minute bars from 2020-01-01, the same store the backtest engine reads. US: SPX, XSP, NDX, VIX and SPY, QQQ, IWM, GLD, DIA, TQQQ, AAPL, TSLA, NVDA, GOOGL, AMZN, META, MSFT, AMD, PLTR, NFLX, INTC, GOOG — OPRA minute bars from 2021-08-16. TWO MODES. Pass date (YYYY-MM-DD) for ONE session's curve. Omit it for the HISTORICAL profile over sessions trading days ending at end_date (sessions 0 = pick by expiry cadence: 60 for the daily names, 20 for a weekly like NIFTY or SENSEX, 12 for a monthly — so the WINDOW is comparable rather than the count; ask for more explicitly if you want it) (default: the latest session) — median premium by time of day with a 25th-75th percentile band, the median full-day decay, how often the premium finished lower than it opened, and when it typically bottoms. dte is days to expiry: 0 (default) is the NEAREST real expiry. That is same-day where options expire daily (SPX/SPY/QQQ); in India, post-SEBI, only NIFTY and SENSEX carry a weekly (NIFTY expires TUESDAY) and the rest are monthly, so a 0DTE profile there samples expiry days only — which is correct: blending a 0DTE curve with a 6DTE one describes no tradeable thing. The ATM strike is fixed at the session open and every curve value is a PERCENT OF THAT SESSION'S OPENING PREMIUM. A RISING LINE MEANS PREMIUM EXPANDED, not a loss — the straddle gains when the underlying outruns time decay. This is market data, not a position: never present it as P&L, and never turn it into advice to sell or buy straddles. Sessions are aligned on the venue's OWN wall clock — Eastern for the US (so summer and winter sessions superimpose despite DST) and IST for India — and early-close half-days are excluded unless include_half_days is set. Indian bars end 15:30 IST: NSE has run F&O to 15:40 since 2026-08-03 and those minutes are not imported, so say so rather than implying the curve runs to the real close. No auth required — this is market data, not account data.

tt_straddle_live

ChatGPT
What the ATM straddle is worth RIGHT NOW, and what it has done since today's open, in rupees (or dollars), minute by minute. WHICH OF THE THREE: tt_straddle_chart is the one contract for a SESSION's line, today or a past date — reach for it first, including for a past session. This tool is the live minute-by-minute read of TODAY and takes no date. tt_straddle_decay is the HISTORICAL PROFILE across many sessions (percent of each session's open), not a chart of one. It reads the ENGINE'S OWN live tick store, so it sees today; the historical companion tt_straddle_decay reads the nightly backtest store and cannot. USE THIS when the question is about NOW or TODAY ("what's the straddle at", "how much has it decayed today", "is premium holding up"). USE tt_straddle_decay when the question is about the PATTERN across many sessions, or about any PAST date — passing it a date returns this exact absolute-price shape for that session. Returns the minute series plus the numbers that belong beside it: strike, CE and PE separately, spot, SYNTHETIC FUTURE (strike + CE - PE, the forward the options are pricing — quote it next to spot when they diverge), days to expiry, open/high/low, and the time of the last point. expiry (YYYY-MM-DD) and strike are optional; the nearest quoting expiry and the ATM strike are used by default, and available_expiries lists the rest. Say the time of the last point rather than implying a close — this moves. MARKET DATA, NOT ADVICE. No auth required.

tt_strategy_performance

ChatGPT
How is ONE of the signed-in user's deployed strategies PERFORMING (the money question, distinct from tt_diagnose_strategy's "is it broken"). Returns total P&L over the window plus the daily series and the stats that matter: win-days vs loss-days, win-rate, avg win-day vs avg loss-day, payoff ratio, best/worst day, daily volatility, max drawdown, and volatility-vs-return. Keyed by the same SID as diagnosis, so you can say both "it's not broken" AND "but it's barely net-positive with huge daily swings". Present the numbers, then give a DESCRIPTIVE read — quantify the behaviour; do NOT give buy/sell/allocation advice (that's investment advice on live money). Data is T-1; P&L is TT's reconciled figure. AUTH-REQUIRED + ownership-gated. from_date/to_date are ISO dates (empty = TT's default current-month window).

tt_update_signal_bridge

ChatGPT
Add or remove symbols (stocks, futures, crypto, option rules) in an existing Signal Bridge, and optionally rename it. The template is edited IN PLACE: the template id and the linked API token stay the same, so the user's existing client and signal links keep working. Settings (exchange, capital, session, exit minutes, working days, intraday, products, expiry-day exit) are kept from the stored template, and every Initialize Variables value the user tuned (master target/SL, caps, per-symbol sizing of symbols that stay) is carried over. New symbols get the defaults. Refuses with BRIDGE_DEPLOYED while the strategy is deployed, has subscribers or is public: the rebuild replaces every set, so a running deployment would lose track of its open positions. Tell the user to stop and exit the deployment first, then edit — nothing was changed. BRIDGE_NOT_FOUND = not one of the user's Signal Bridges. CONFIRM the new basket with the user first (dry_run=true shows it). Returns what tt_create_signal_bridge returns (template_id, basket, auth_token, python_client, signal_links, guide_markdown, ...) plus changed.added_symbols / removed_symbols and the kept settings. Tell the user what was added and removed; relay python_client verbatim if they want the updated client. AUTH-REQUIRED.

tt_update_strategy

ChatGPT
Apply edits to an existing strategy and save. LIVE-EDIT CONFIRM GATE: if this template is DEPLOYED, has SUBSCRIBERS, or is PUBLIC, a non-dry-run call refuses once with LIVE_EDIT_CONFIRMATION_REQUIRED — carrying the blast radius, the live-position consequences, and a copy alternative. RELAY those to the user, ask one confirm question, and only after the user explicitly agrees re-call with the SAME arguments plus live_edit_confirmed=true. Never set it on your own initiative. MODIFY WORKFLOW (read this before any edit — there is NO rollback): 1. tt_get_strategy(<id>) FIRST and keep the result. It is your only snapshot; nothing here can undo a write. (tt_get_strategy also re-validates the STORED strategy, so it doubles as a health check on what is live right now.) 2. Rehearse with dry_run=True. Same validation, no write. 3. Apply, then re-read to confirm what actually persisted. Prefer tt_apply_strategy_patch for a surgical single set/condition/leg change; this tool replaces whole top-level fields, sets included. Heads-up when diffing before/after: a create/patch INJECTS blank Add Repair / Exit envelopes into each set as scaffolding, so a strategy read back will show conditions you did not author. They are inert placeholders, not a bug and not content loss. A sets replacement that would REMOVE the strategy's Universal Exit is refused (STRATEGY_EDIT_UE_REMOVED) unless allow_universal_exit_removal=True — pass it only when the user explicitly wants the UE gone. Edits top-level scalar fields (name, description, capital_required, currency, max_multiple / min_multiple, exit settings, tags, python_code, etc.) AND — since 2026-06-29 — a full sets replacement (structural). A structural edit routes through the clean create-shape + content-preservation check; if TT silently drops content it FAILS LOUD (STRATEGY_UPDATE_CONTENT_DROPPED). For SURGICAL add/remove/modify of an individual set/condition/leg, prefer tt_apply_strategy_patch. Do NOT recreate the strategy. Pass the TEMPLATE id, not a deployed SID — they are both 8-digit numbers and cannot be told apart by shape; get the template id from tt_list_my_strategies or a strategy's edit URL. Call tt_list_editable_fields() to see the full list of allowed keys. Args: strategy_id: integer ID from a prior create or list call. edits: dict of {top-level-field: new-value}. Non-empty. sets (the whole array) is allowed for structural changes. dry_run: validate and report what WOULD change without writing. Defaults to False (this tool writes by default, unlike tt_apply_strategy_patch). A dry run cannot predict a SERVER-side content drop — only the real POST can. live_edit_confirmed: set True ONLY after the user has been shown the LIVE_EDIT_CONFIRMATION_REQUIRED blast radius and consequences and explicitly agreed to edit the live template. Never set it on your own initiative. exchange_brokers: {exchange: broker_id}, e.g. {"BFO": 1021}. Send ONLY after a STRATEGY_EXCHANGE_BROKER_REQUIRED refusal, with the broker the USER picked from that error's details.missing[].brokers for each exchange. Tradetron then adds the broker to the user's running deployments of this template. Never guess or pick one yourself. Returns on success: {"ok": True, "data": {"id", "name", "edit_url", "request_id", "changed_fields": [<persisted keys>]}} SET IDS ARE NOT STABLE ACROSS AN EDIT. There is no partial-field wire here: any edit other than python_code reposts the whole body, and Tradetron deletes and recreates the SET rows on every such write. So a one-scalar edit — a description change — moves every set id, and each condition's strategy_template_set_id moves with it. Condition and leg ids are preserved. changed_fields reports the FIELDS you asked for and that persisted; it does not, and cannot, report the row churn. Never cache a set id across an edit — re-read with tt_get_strategy instead. Possible error codes worth surfacing to the user: STRATEGY_VALIDATION_FAILED — edits would produce invalid spec STRATEGY_UPDATE_CONTENT_DROPPED — structural edit lost sets/ conditions/legs server-side STRATEGY_EXCHANGE…

tt_validate_markdown

ChatGPT
Validate a strategy spec (markdown OR JSON) against the locked schema. Auto-detects format: text starting with '{' is treated as JSON, otherwise as markdown (the Tradetron strategy-markdown grammar). mode: 'create' (strict, for new strategies; checks int types tightly) 'update' (lenient, for already-existing strategies fetched via get_strategy where some legacy types are looser). ALWAYS call this BEFORE create_strategy. The validator catches: - SCHEMA_LOCK rule violations (settings wrapper, positions vs legs, etc.) - Forbidden condition keys (condition_action, parent, sort, c_new) - Type mismatches (instrument as string, fee_frequency as 'Month', etc.) - Unknown keywords (typos, hallucinated function names) - Structural issues that TT would silently drop on submit Returns a structured error list with hints for each issue, so you can fix the spec and retry without making a round-trip to TT. GAPS — the trading decisions the user never made. data.gaps lists each missing or ambiguous piece (no exit, no stop-loss on sold options, a stop-loss or target the description promises but the logic lacks, an unstated expiry or quantity, re-entry after an exit, a keyword that does not run) as {code, field, question, options: [2-4 x {label, detail, value}], default, blocking}. When gaps is non-empty, do NOT guess and do NOT ask open-ended: put each gap to the user as its question with its options, one question per gap, and mark the option whose value equals default as the usual choice (default: null = no safe default, let them pick). Settle every blocking: true gap before you create; a non-blocking gap may take its default when the user says to go ahead. Build exactly what they pick, then validate again. When the user did not state a leg's expiry or the quantity, leave that Expiry cell blank or the Qty column out instead of guessing: the conventional default is applied and the gap comes back so you can confirm it. Gaps never change valid, errors or warnings.

tt_validate_python

ChatGPT
Security-check a custom Python snippet before embedding it in a strategy. Custom Python in a Tradetron strategy runs on shared TT infrastructure, so it is gated by a strict deterministic policy: Tradetron keywords and the tt_-prefixed transient wrappers tt_set_runtime/tt_get_runtime are allowed (the BARE get_runtime/set_runtime are the raw engine functions and must never be called from a block — they raise at live deploy, and are flagged here as a warning); imports, dunder/ introspection access, eval/exec/compile/open/getattr/globals, string .format() escapes, function definitions (def and lambda), and huge allocations are rejected. Loops only when bounded: a for over range() with integer-literal bounds or a literal tuple/list, at most 100 iterations per loop, 500 per block, 2 levels deep — while and comprehensions are rejected. Use a loop only where the logic cannot be written without one. Call this BEFORE proposing python_code in tt_create_strategy / tt_update_strategy. Returns {valid, code_hash, errors[], warnings[]} with a specific code + message + line for each issue, so you can fix the snippet without a round-trip. The same gate runs server-side on every create/edit, so anything this rejects will also be rejected on save. code_hash is the sha256 of the NORMALISED code — line endings unified, per-line trailing whitespace removed, leading and trailing blank lines dropped — which is also the form the code is saved in. So the hash of what you sent matches the hash of what reads back, and a trailing newline you add is not stored.

tt_wallet_balance

ChatGPT
Show the user's Tradetron wallet balance and what a backtest costs. Backtests are charged to the Tradetron wallet. Call this when the user asks about their balance, asks how much a backtest costs, or after a run is blocked for insufficient balance. Returns {wallet_balance, backtest_price, backtests_affordable, backtests_affordable_from_wallet, backtest_pack?}. The two affordable keys are the SAME figure; quote one. LEAD WITH backtest_pack WHEN IT IS PRESENT: an account holding a prepaid pack spends CREDITS first, so its runs cost ₹0 and the cash balance never moves. spendable_now is what a run today can draw; it is 0 on a pack whose billing cycle has ended, which is not the same as no pack. Relay the balance verbatim; never invent or estimate a figure. If the balance could not be read, say exactly that. Adding funds is done by the user on the Tradetron website; this tool returns no payment link.

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/tradetron"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/tradetron)