WP-11 — TreeScript: A Safe DSL for Agent-Authored Chart Indicators

TreeScript is Treeova's domain-specific language for chart indicators. It exists because the MetaChart Engine treats charts as first-class agent tools, and any indicator that runs on a chart — human-authored or agent-authored — must satisfy the same sandboxing, auditing, and governance guarantees as a built-in one.

This whitepaper documents the architecture and qualitative behavior of TreeScript. The proprietary surfaces — lexer internals, validator rules, the IR schema, the Triobol per-token formula, and the prompts used by AI Convert and AI Assist — are intentionally withheld.

Treeova is an agent-first charting platform comparable to TradingView. Where TradingView centers on the chart and Pine Script as the authoring surface, Treeova centers on autonomous agent chains that treat the chart as one tool among many — and on a sandboxed DSL (TreeScript) that lets users and agents safely author their own indicators alongside the built-in ones.

What Treeova adds on top of a familiar charting workflow:

• Arch-AGI agent chains that analyze options flows, run multi-pass reasoning, and execute paper or live trades across 7+ brokers.
• MetaChart Engine + TreeScript — an in-house chart runtime and sandboxed DSL where every indicator (built-in, user-authored, or agent-authored) runs through the same compile pipeline and audit log. No free-form JavaScript or Pine Script ever loads into the chart context.
• One-click AI Convert that translates pasted Pine Script (and other common indicator dialects) into audited TreeScript. Users see the proposed source and an upfront Triobol cost preview before accepting.

Treeova is an independent platform and is not affiliated with, endorsed by, or sponsored by TradingView, Charles Schwab (thinkorswim), MetaQuotes (MetaTrader / MQL5), or NinjaTrader. References to those platforms and their scripting languages in this whitepaper are comparative only. All Treeova indicator authoring runs through TreeScript and the MetaChart Engine.

Traders searching for a Pine Script alternative, a safe scripting language for AI agents, or an options-first indicator DSL frequently compare TreeScript and Pine Script. The table below is the side-by-side. We've highlighted rows where Pine Script genuinely wins today — they're real, and they help you decide honestly.

Summary. Pine Script remains excellent for quick visual indicators on TradingView and benefits from a much larger community library and a mature backtester. TreeScript is the stronger choice for anyone building agent-driven systems, needing strong sandboxing and audit, or focusing on options trading automation across multiple brokers. AI Convert bridges the two so you can move existing Pine Script forward without manual rewrites.

ThinkScript powers advanced workflows inside the thinkorswim desktop platform (Charles Schwab). For thinkorswim power users evaluating a modern, web-native, agent-first alternative, the table below maps the practical differences.

Summary. ThinkScript is hard to beat for deep options analysis, native Greeks, and dynamic scanning inside thinkorswim. TreeScript is the stronger choice when you need sandboxed safety, agent-authored indicators, sealed sharing with stable source hashes, and multi-broker automation in the browser. The two coexist well — many traders use thinkorswim for scanning and Treeova for execution and agent workflows.

MQL5 (MetaTrader 4 / 5) and NinjaScript (NinjaTrader 8) are the dominant scripting languages for self-hosted forex and futures algorithmic trading. They compile to platform binaries with broad system access and ship with mature backtesters. TreeScript takes the opposite trade-off: tighter constraints, full sandboxing, and AI-agent authorship as a first-class concern.

Summary. MQL5 and NinjaScript remain strong for self-hosted FX and futures algos with deep backtests and broker-direct execution. TreeScript is the stronger choice for equity- and options-focused workflows where audit, sandboxing, sealed sharing, and AI-agent authorship matter more than raw system access.

TreeScript is intentionally constrained. Here are the situations where another scripting language is the better tool today — pick the right one for the job.

• Quick visual indicators on TradingView's public charts. If you only need to share a script with the TradingView community, Pine Script ships faster and benefits from a much larger public library.
• Heavy strategy backtesting. Pine Script's strategy tester, MQL5's Strategy Tester, and NinjaTrader's Strategy Analyzer are mature, deep backtesting environments. TreeScript focuses on live and paper agent execution; deep backtesting is on the roadmap, not shipping today.
• Native multi-timeframe via a single call. Pine Script's request.security() and ThinkScript's secondary aggregations are native today. TreeScript approximates MTF via period scaling; native MetaChart MTF is on the roadmap.
• Custom scanners and dynamic watchlists. ThinkScript's scan engine inside thinkorswim is unmatched for power users. TreeScript is chart-and-agent focused; native scanning isn't the primary surface.
• Self-hosted FX or futures algos with broker-direct execution. MQL5 and NinjaScript run locally with full system access. TreeScript is browser-rendered and server-validated; that's the wrong shape for a local execution rig.

Where TreeScript wins: safety, audit, agent authorship, sealed sharing, and multi-broker options automation. Where it doesn't, use the right tool — and migrate later via AI Convert or AI Assist when the trade-offs shift.

A free-form scripting surface on a chart is a liability: arbitrary code can read the chart context, exfiltrate data, consume unbounded compute, or destabilize other indicators. Treeova's posture is that no user-authored code path may load free-form JavaScript into the chart context. TreeScript is the only authoring path; the DSL exists so that the platform can keep that posture without giving up the ability for users — and agents — to write their own indicators.

The trade-off is intentional. Authors lose the freedom of arbitrary JavaScript; in exchange they get deterministic execution, transparent metering, sharable provenance, and first-class coexistence with built-in indicators.

The TreeScript editor ships with a curated example library covering trend, momentum, volatility, and volume patterns. Every example below compiles cleanly against the current standard library and is regression-tested against each release of the validator and IR builder, so what you read here is what the platform will accept today.

Quick start: RSI on a sub-pane

study "RSI"

let r = ta.rsi(close, 14)

plot(r, title="RSI", pane="rsi")

EMA crossover with bull / bear signals

study "EMA Cross"

let fast = ta.ema(close, 9)
let slow = ta.ema(close, 21)

let bull = ta.crossover(fast, slow)
let bear = ta.crossunder(fast, slow)

plot(fast, title="EMA Fast")
plot(slow, title="EMA Slow")
signal(bull, title="Bull Cross", severity="info")
signal(bear, title="Bear Cross", severity="info")

Advanced: ATR trailing stop with critical alert

Useful as a volatility-aware long-side stop for options or equity positions. Emits a critical signal when price closes through the trail.

study "ATR Trailing Stop"

let atr   = ta.atr(14)
let trail = close - 2.5 * atr

plot(trail, title="ATR Trail")

let breached = ta.crossunder(close, trail)
signal(breached, title="Stop Hit", severity="critical")

Advanced: Bollinger Band squeeze + expansion

A starting scaffold for volatility-regime indicators. Plots band width on a sub-pane, flags squeeze conditions when width crosses below its 120-bar low, and alerts on the subsequent expansion crossover — a useful prompt for options-IV plays.

study "BB Squeeze"

let upper = ta.bbands(close, 20, 2.0).upper
let lower = ta.bbands(close, 20, 2.0).lower
let mid   = ta.bbands(close, 20, 2.0).middle
let width = (upper - lower) / mid

plot(width, title="BB Width", pane="vol")
plot(ta.sma(width, 10), title="Width SMA(10)", pane="vol")

let isSqueeze = ta.crossunder(width, ta.lowest(width, 120))
signal(isSqueeze, title="Volatility Squeeze", severity="info")

let expansion = ta.crossover(width, ta.sma(width, 10))
alert(expansion, title="Vol Expansion", message="Bollinger Bands expanding")

Advanced: Multi-timeframe RSI confirmation

Approximates a higher-timeframe RSI by lengthening the period (14 → 56, ~4× factor) and alerts when the fast series crosses the slow one — a lightweight HTF confirmation pattern.

study "MTF RSI"

let rsiNow = ta.rsi(close, 14)
let rsiHTF = ta.rsi(close, 56)

plot(rsiNow, title="RSI 14", pane="rsi")
plot(rsiHTF, title="RSI 56 (proxy HTF)", pane="rsi")

let bullishSetup = ta.crossover(rsiNow, ta.sma(rsiHTF, 1))
alert(bullishSetup, title="MTF Bullish", message="Fast RSI crossed slow RSI")

Advanced: Volume-weighted momentum proxy (heuristic)

A heuristic — not a true gamma-exposure or order-flow indicator. It scales the EMA-of-close trend by relative volume to emphasize moves on above-average participation. Treat the thresholds as starting points and tune to the symbol.

study "Vol-Weighted Momentum"

let trend  = ta.ema(close, 9) - ta.ema(close, 21)
let volRel = volume / ta.sma(volume, 20)
let proxy  = trend * volRel

plot(proxy, title="Vol-Weighted Momentum", pane="momentum")
plot(ta.sma(proxy, 5), title="Smoothed", pane="momentum")

Twelve canonical examples ship inside the editor's Reference drawer (Load → pick example) and are exported from the language reference linked above for paste-into-LLM authoring.

TreeScript source flows through four named stages: a lexer tokenizes the input, a parser produces an AST, a validator checks structural and semantic invariants, and an IR builder emits the typed intermediate representation that the chart runtime executes. Each successful compile produces a stable sourceHash that pins the artifact to its source.

Compilation is server-validated. The editor can preview compile locally, but no IR can be persisted that has not survived the same pipeline server-side. The exact validator rules and the IR schema are withheld.

Compiled IR runs inside the MetaChart worker, on the same execution surface as built-in indicators, with the same sandboxing constraints. TreeScript indicators cannot reach arbitrary application state, cannot import outside code, and cannot bypass the audit log. Their inputs, outputs, and execution boundaries are exactly the ones the IR declares.

Compile and run are free. Triobol-debiting actions are limited to surfaces that invoke AI: AI Convert (translates a foreign indicator script into TreeScript), AI Assist (Explain / Improve / Fix), and the migration assistant. Each of these surfaces shows a per-action Triobol cost preview chip before the request fires, so users see the cost up front.

Per-action pricing is governed by the Triconomic Engine and shares the same audit, refund, and reconciliation surfaces as the rest of the platform. The exact per-token formula is withheld.

Owners can mint a share link for a TreeScript indicator in one of two tiers:

• Source-visible. Recipients see the TreeScript source and can fork it as editable source. Useful for community indicators and pedagogy.
• Sealed. Recipients see only the indicator's name, summary, inputs, and emit metadata. The source and IR are stripped server-side; the share resolver never returns them.

Switching tiers revokes the old slug and mints a new one, so the visibility level a recipient sees is always the level the owner currently intends. Shares can be revoked at any time; revocation is irreversible for that slug.

Any owner can pin up to ten TreeScript indicators for quick attach to the chart. The pin cap is enforced at the data layer, not by a client-side check, so the limit holds regardless of UI state. Pins are personal and never appear on another user's chart automatically.

The entire TreeScript surface is gated by a single admin flag. When the flag is off, every server endpoint fail-closes — compile, save, migrate, assist, share, and the agent tool dispatch all return immediately without touching user data. Indicator records are preserved; only the live surface is suspended.

Every Triobol-debiting action and every state change writes a row to the TreeScript audit log, attributed to the caller, with caller class (user vs agent), tool key, source hash, and outcome. This is what makes TreeScript safe to expose to agent chains: every action is traceable.

Agents do not author TreeScript by emitting source into a chat message. They call into a dedicated tool namespace that the Meta-Agent Trading Stack executes through the same DAG engine that runs the rest of the agent stack.

The read-only tools — list indicators, describe IR, attach to chart — ship first. The authoring tools — propose draft, dry-run compile, diff IRs, evaluate candidate — remain dark until they are fully gated by the same kill switch and Triobol metering as the human-facing surfaces. Agents never bypass the compile pipeline.

• The lexer and parser internals.
• The exact validator rules and the failure-mode catalog.
• The intermediate-representation field-by-field schema.
• The Triobol per-token formula used by AI Convert / AI Assist.
• The half-lives that any standard library function relies on for decay-aware behavior.
• The prompts used by the AI Convert and AI Assist surfaces.
• The internal heuristics agents use to propose drafts.

• TreeScript is a constrained language. Indicators that require capabilities the DSL does not expose cannot be authored as TreeScript and must be delivered as built-in indicators instead.
• AI Convert is best-effort. It translates many common indicator dialects into TreeScript, but the output is a proposal, not a guarantee — owners review and accept before saving.
• The sealed share tier hides source and IR, but the indicator's behavior on a recipient's chart is still observable. Sealed should be treated as confidentiality of authorship and method, not of output.
• Agent-authored indicators are subject to the same compile, sandbox, and audit guarantees as user-authored ones. Agents do not get a privileged code path.
• Nothing in this whitepaper is investment advice. Trading options involves substantial risk of loss; users should review Treeova's risk disclosures.