Agent Playbook

You say: "Follow ASML on its Amsterdam listing."

The agent does: symbol-search to resolve the exact ticker, exchange, and currency → then sends two commands: subscribe-price-feed (starts the platform collecting data for EURONEXT-ASML) and follow-symbol (puts it on your watchlist). Both are needed and both are idempotent — re-following is harmless.

You get: the symbol on your watchlist with history backfilling, analysis triggering, and news collection starting.

A ticker alone is ambiguous — MSFT and TSLA exist on several venues — so agents always resolve through search first and use the EXCHANGE-TICKER feed id everywhere after.

You say: "Give me a full read-out on NVDA."

The agent does (read-only): get-symbol-situation (latest price + freshness) → get-price-variations (1D to 5Y moves) → get-analysis-metrics (the objective Key Metrics) → get-news-sentiment (tone of recent coverage) → get-analysis (every AI analyst's verdict, confidence, and written reasoning). If the analysis looks stale it can trigger analyze-symbol — idempotent — and re-read.

You get: a grounded brief built from the same data the symbol view renders — current situation, trend, valuation, sentiment, and persona-by-persona reasoning.

You say: "Group my chip stocks into a Semiconductors panel."

The agent does: list-watchlist-panels to see the current layout → configure-panel to create (or rename) the panel → assign-symbol per feed to move it in.

You get: the reorganised watchlist, live on every device. Panels are pure organisation — membership never affects data collection, and the default panel always exists as the home of unassigned symbols.

You say: "Make me a strategy for MSFT: buy when the 20-day average crosses above the 50-day, sell on the cross back down, 5% stop."

The agent does: sends your prose to compile-thesis — the compiler itself classifies the idea and produces the deterministic spec (the agent never hand-writes spec JSON). Compilation is asynchronous: the outcome appears in list-theses, where the compiled spec is readable and reusable.

You get: a named, inspectable strategy — the same artifact the UI's Review button produces — ready to backtest or run.

You say: "Backtest it on MSFT over the last two years."

The agent does: calls the run-backtest query with the compiled strategy and the feed — it is synchronous, the full result returns in the response. Same engine as the UI: next-bar-open fills, per-side costs, marked-to-market drawdown, buy-and-hold benchmark.

You get: realized/unrealized P/L, costs, win rate, max drawdown, and the benchmark comparison — honest numbers an agent can reason over before recommending anything.

You say: "Run it live on MSFT and tell me when it signals."

The agent does: configure-algorithm (binds the compiled strategy to the feed) → run-algorithm to start it. The platform evaluates every closing bar; decisions land in list-algorithm-signals, which the agent can check on demand. pause-algorithm and remove-algorithm complete the lifecycle.

You get: a strategy working the market for you, signal-only — nothing trades until a route exists and you enable it. The chart legend shows it running with the same play/pause controls.

You say: "Send that strategy's signals to my paper account, one share per entry — and to my journaling webhook."

The agent does: list-brokers / list-webhooks to name the destinations → configure-signal-route per destination (broker route with entry quantity, or webhook route) → asks for your explicit go-ahead, then enable-signal-route — a high-impact command; broker routes place real orders.

You get: every future signal fanned out per route — orders on the broker (exits capped by the real position, never a short), HMAC-signed deliveries to the webhook — with per-route execution outcomes recorded on each signal in list-algorithm-signals.

You say: "I want to beat a global index fund over years, adding money monthly — structure it for my ISA."

The agent does: follows the workflow's elements — confirms the long-term frame, reads your broker connection for the buyable universe and account currency, sizes the contribution against your real free cash (get-broker-cash), surfaces per-venue currency and cost facts, and assembles holdings you pick into weights totalling 100% with a benchmark — then configure-portfolio, saved disabled.

You get: a fully structured portfolio waiting for your decision. The agent structures and computes; it does not pick for you, and enabling is yours. Cross-currency holdings are fine — FX is a cost fact the platform handles, not a constraint.

You say: "Enable my portfolio, and each month show me the proposal before anything happens."

The agent does: set-portfolio-enabled to start the cadence → reads each round's quote via list-portfolio-proposals (resolved orders, banked slices, FX facts) → presents it and, only with your explicit approval, sends approve-portfolio-proposal — high-impact, once per period. Steering rides the same lane: request-portfolio-review (ad-hoc, optional one-off amount), cancel-portfolio-review, decline-portfolio-proposal to skip a month, retry-portfolio-execution for a broker-rejected slice. portfolio-performance and portfolio-performance-history close the loop.

You get: the monthly discipline executed without emotion — planned from fresh broker facts, approved by you, measured from your own fills.

You say: "Buy 2 STMPA on my IBKR live account."

The agent does: list-brokers to name the exact connection → sanity-checks with get-broker-cash (buys) or get-broker-position (sells) → asks for your confirmation, then submit-order — high-impact, pass-through, never resized or retried by the platform. The verdict is asynchronous: acceptance, rejection (with the broker's verbatim reason), and fills arrive on the order's record — list-orders / get-broker-order to follow it, cancel-order while it is still working.

You get: the order at your broker exactly as specified, and its full life visible in the Activity tab — origin-stamped manual.