NexusTrade Financial MCPVerifiedFeatured

Aurora agent surface (no LLM cost on this call itself — pure DB read). Useful only when the user is actively operating an Aurora agent. For strategy creation/backtesting prefer the structured no-LLM tools (create_portfolio with full JSON payload, backtest_portfolio, query_*, fetch_portfolios). List your Aurora agents with pagination using the same query shape as the agent controller.

⚠ COSTS LLM CREDITS on the NexusTrade account — spins up an Aurora agent via Router V5 classification + ReAct execution loops, billed per token. **Manual approval required**: do NOT call unless the user explicitly asked to launch an Aurora agent. For strategy creation/backtesting/analysis prefer no-LLM tools: structured create_portfolio (pass full IPortfolio JSON), backtest_portfolio, query_backtest_history, query_*, fetch_portfolios. Create a new autonomous Aurora agent using the same body shape as POST /api/agent. When maxIterations or automationMode are omitted, applies the user's saved ChatSettings. Agent models are product-locked (openai/gpt-5.6-luna planner/executor and the platform tool-role defaults) and cannot be overridden.

⚠ COSTS LLM CREDITS — same path as POST /api/chat. Router V5 classifies the message: Ask Clarity (persisted), Create Agent (spawns Aurora research), or single-tool fulfill (queued prompt job). Use this for chat turns; use create_agent only when you explicitly want agent spawn without single-tool fulfill. Respects session_depth smart|deep.

Aurora agent surface (no LLM cost on this call — pure DB read). Only relevant when the user is actively working with an Aurora agent. Returns status, plan, messages, config. Address by agentId OR by exact title (case-insensitive); provide exactly one. Duplicate titles fail closed with candidate ids. Polling/liveness: use agent.lastProgressAt (advances during sandbox steps, tool cards, LLM rounds, and — while waiting_for_subagents — when children progress) — NOT agent.updatedAt (state transitions only; stays frozen by design while parked on subagents so the waiting-no-wake detector can prefilter). For waiting_for_subagents, a frozen lastProgressAt means children stopped progressing; confirm via child agent statuses. Sandbox step detail: agent.messages[*].data.steps. Poll until status is terminal (complete/stopped/error).

⚠ COSTS LLM CREDITS when messages are supplied — re-runs the Aurora planner LLM. Manual approval required for message updates; do NOT call unless the user asked to update an active Aurora agent. Address the agent by agentId or by exact title. Renaming needs no LLM call: pass newTitle, or pass agentId together with title. Agent models are product-locked and cannot be changed.

Aurora agent surface (no LLM cost on this call — pure DB read). Only relevant when inspecting an Aurora agent run. Raw trace / trajectory events for an agent (for inspection or building evaluator input). Address by agentId OR exact title (XOR).

⚠ COSTS LLM CREDITS — runs a server-side LLM evaluator against an agent trace. Manual approval required; do NOT call unless the user asked to score an agent run. Run an evaluator prompt on a completed (or stopped) agent. Defaults to the NexusTrade Agent Run Evaluator but accepts any custom prompt name for goal-oriented scoring.

Aurora agent surface (no LLM cost — pure DB write). Only relevant when sharing an Aurora agent. Share an agent publicly and get a shareable URL. Creates a PublicAgent with the full conversation trace and subagent data.

Query trading events for a portfolio. Filter by event type, date range, with pagination. PREFERRED drill-down after summarize_portfolio_events. Defaults to last 7 days when start_date omitted (45s timeout). Live portfolios older than 72h scan Tigris Parquet — pass a recent start_date to stay in hot Mongo. For option rebalance audits use OpenOptionSignal + Order, not RebalanceSignal. Zero research token cost.

Query Mongo hot-store events from a backtest run with generate_events=true. Backtest event traces expire after 3 days and are not archived to Tigris. Returns signals, orders, trading audits, and other detailed events. Zero research token cost.

Aggregate audit summary for a portfolio's events. Returns counts by event type, fills by ticker+side, rejection reasons + samples, OrderGuard reasons, Buy/Sell signal cadence, and 1-2 sampled payloads per event type. Use INSTEAD of paging raw rows when auditing — one call vs many paged calls. Defaults to last 7 days and sample_limit 10000 when omitted (45s timeout). Widen start_date or sample_limit only when the default window is too narrow. Zero research token cost.

Aggregate audit summary for a backtest's Mongo hot-store events. Backtest event traces expire after 3 days and are not archived to Tigris. Same shape as summarize_portfolio_events. PREFERRED over query_backtest_events when auditing a fresh backtest — one call vs many paged calls. Use query_backtest_events only when you need to drill into specific events the summary flagged. Zero research token cost.

Return a time series of {time, value, cash, positionValue, comparisonValue} per tick for a completed backtest. Reads from the backtesthistories collection (full minute-resolution; 30-day TTL). Use this to find suspicious single-tick portfolio value jumps without needing the codebase — feed the result through your own jump-detection logic. Cash is derived as value minus Σ(position.quantity × lastPrice). `reservedCollateral` is NOT persisted yet and will be omitted. Zero research token cost.

Return the parent backtest document's status, error, interval, timestamps, elapsed time, and completed statistics without reading history/events. Use immediately after backtest_portfolio or before query_backtest_history so ERROR/PENDING/RUNNING states are explicit. Zero research token cost.

Poll an async ask_corpus semantic query by its corpus_query_id. Returns PROCESSING (retry), COMPLETED (the cited answer), or FAILED (error). Zero research token cost. Only the slow semantic path is async; ask_corpus returns handoffs inline.

Poll an async run_compute job by its compute_job_id. Returns PROCESSING (retry shortly), COMPLETED (dataset/report output + log key), FAILED, or a paused/resumable disposition. Obey next_action: manual_resume_required → resume_compute. next_action=continue_via_run_compute belongs to the in-app agent surface, which re-enters the same interactive attempt with its transcript; over MCP the closest action is a NEW run_compute with mount_workspace_from_compute_job_id set to this id, which inherits the job's /work but not its attempt. Oneshot run_compute over MCP is async — it returns a compute_job_id you poll here.

Cancel an in-flight async run_compute job by compute_job_id. Stops the worker between fixer attempts, tears down the sandbox machine, and releases the lease. Poll get_compute_status until status is CANCELLED.

Resume one interrupted or deliberately paused async run_compute job by compute_job_id. Autopilot: continues durable orchestration (/work, completed host calls, grading) including QUALITY_REJECTED. Interactive: raises a spend ceiling when BUDGET_PAUSED; for QUALITY_REJECTED returns CONTINUE_VIA_RUN_COMPUTE — call run_compute again with the same compute_job_id instead. Obey next_action from get_compute_status. Does not start a replacement run. Poll get_compute_status after it returns. Returns LEGACY_NOT_RESUMABLE when no orchestration checkpoint exists.

Cheap liveness check for one or more public URLs BEFORE committing a minutes-long run_compute to a data source. Returns {url, status, live} per url (live = reachable 2xx/3xx). Use this to skip dead sources (e.g. a 403/404) and pick a working one — a dead URL is caught in ~1s instead of a wasted compute job. Goes through the same SSRF guard as the fetch host-call (private/internal IPs are blocked).

Derive deployment, optional regime overlay, drawdown, and vs-comparison metrics from backtesthistories without dumping the full tape. EOD ticks by default. Replaces query_backtest_history + local Python for Gate 4/5/6 posture audits. Zero research token cost.

Read the finalize-time breadthSummary snapshot from a completed backtest: participation rollups, per-underlying fill/rejection counts, and Gate-1 flags (namesWithRejectionsAndZeroFills, namesWithZeroResolutionAttempts). Zero research token cost. Returns status unavailable for backtests predating the writer — never fake zeros.

Compare 2–10 completed backtests against a baseline: campaign-log stats table, per-run stats deltas, tape first-divergence forensics, optional order diff. tolerance_bps: 0 = exact repro gate. Zero research token cost.

Deep-copy a source chat or deployed portfolio, apply JSON-Pointer patches (replace/add/remove), validate, and persist a new immutable ChatPortfolio with fresh strategy IDs. Atomic: unresolved patch paths are hard errors. dry_run returns applied diffs without persisting. Zero research token cost.

Preview/builder twin of create_portfolio. Runs the SAME construction + per-strategy validation (Portfolio/Strategy/Condition/Indicator) as create_portfolio but PERSISTS NOTHING. Accepts the same IPortfolio JSON (all fields optional so partial drafts can be checked). Returns the canonicalized portfolio plus a per-component issue list (path + component + message) so you can see exactly which strategy/condition/indicator is wrong before committing. A draft that previews clean cannot fail on create_portfolio. Zero research token cost. Custom data sources: none yet. Create one with run_compute (pass name and point_kind to promote its signal output directly), or use dataset_to_indicator with a saved dataset; then reference customIndicatorId in create_portfolio.

List your scheduled trading agents (LaunchAgent strategies). Zero LLM cost — same data path as GET /api/scheduled-agents / the Scheduled Agents UI. Returns each agent’s strategyId, portfolio, schedule summary, active/disabled state, recent runs, and stats (total / active / running now / live portfolios). Use before create_scheduled_trading_agent (upsert) to find existing strategy_id values. Distinct from list_agents (Aurora chat agents).

Fire a LaunchAgent scheduled strategy now (same path as Scheduled Agents UI "Run now" and POST /api/scheduled-agents/:strategyId/run). Zero LLM cost to queue; Worker initializes the agent. Returns durable agentId (prior terminal when continueExisting) plus pendingAgentId. 409 if a run is already in flight. bypass_cooldown defaults true for MCP. Not available on Aurora Agent V5 / Router — MCP clients and humans only.

Create a deployed LaunchAgent strategy on a schedule — the MCP twin of the Scheduled Agents UI. Zero LLM cost to create; LLM credits are spent later when the condition fires and Aurora runs. Without portfolio_id: creates a new paper portfolio (default initial_value=0, Constant frequency, active=true) whose only job is the agent. With portfolio_id: updates the portfolio's existing scheduled agent in place (upsert) — or adds one if none exists. Pass strategy_id to target a specific agent, or mode:"append" to always add a new one. The response lists every strategy on the portfolio. Provide either schedule {frequency, day_of_week, time} or a full condition tree. Prefer list_scheduled_agents first to discover existing agents.

List all available AI models with their IDs, display names, token costs, and capabilities.

Operator tool (no LLM cost — pure DB read). Returns the user's effective ChatSettings: locked agent model config, iterations, automation mode, backtest date window, and related fields.

Operator tool (no LLM cost on this call). Patch agent iterations and/or automation_mode only. Agent models are product-locked and cannot be changed. Returns before and after snapshots.

List all available Aurora prompts/tools with their names, descriptions, and categories.

Aurora agent surface (no LLM cost — pure state transition). Only relevant when actively managing an Aurora agent. Stop a running agent. Sends a cancellation request and cascades to all descendant subagents. The agent must be in an active state (running, initializing, pending approval, etc.).

Aurora agent surface (no LLM cost — pure DB write). Only relevant when managing Aurora agents. Archive an agent (soft-delete). The agent remains in the database but is hidden from default listings. Address by agentId OR exact title (XOR).

Aurora agent surface (no LLM cost — pure DB write). Only relevant when managing Aurora agents. Restore an archived agent so it appears in default agent listings again. Address by agentId OR exact title (XOR).

Aurora agent surface (no LLM cost — pure DB write). Star or unstar a top-level agent for quick sidebar access. Mirrors PATCH /api/agent/:agentId/star. Address by agentId OR exact title (XOR). Omit starred to toggle.

⚠ INDIRECTLY COSTS LLM CREDITS — approving the plan unfreezes the agent which then runs more planning + execution LLM calls. Manual approval required; do NOT call unless the user explicitly told you to advance their Aurora agent. Approve a semi-automated agent that is waiting in pending_plan_approval or pending_action_approval. Auto-detects which approval the agent needs and emits the matching state-machine event so the agent resumes execution. Returns 400 if the agent is not in a pending-approval state.

Aurora agent surface (minimal LLM cost — state transition, no re-planning). Only relevant when actively managing an Aurora agent. Reject a semi-automated agent that is waiting in pending_plan_approval or pending_action_approval. Mirrors POST /api/agent/:agentId/reject, marks the latest assistant message as errored, transitions through the state machine, traces the rejection, and publishes a websocket update.

⚠ COSTS LLM CREDITS — re-runs the Aurora planner LLM after appending the user's follow-up. Manual approval required; do NOT call unless the user explicitly asked to push a message into an active Aurora agent. Address by agentId OR exact title (XOR). Send a follow-up user message to an agent and re-run the planner, matching POST /api/agent/:agentId/message. This can charge planning tokens, rejects actively running/approved states, may recover terminal states, may transition the agent, and publishes websocket updates. It is not an append-only operation.

List or search your portfolios with lightweight metadata (strategy id + name). Matches portfolio name, strategy names, and tickers — same workspace search as the dashboard / GET /api/chat-portfolio. include_chat_portfolios returns workspace DRAFTS only (excludes deployedMirror rows). Recover a past chat draft: include_paper=false, include_live=false, include_chat_portfolios=true, search="Delta 0.07" (then get_portfolio for full strategy JSON). Returns an object: { portfolios, page, limit, total, totalPages, scopes }. Deployed and draft rows page as one list (all deployed, then all drafts), so every row is reachable by walking pages. When search is set, include_positions defaults to false. Use analyze_portfolios only when you need LLM-written analysis.

Fetch one portfolio with full strategy objects (condition, action, indicators), positions, and spread-grouped holdings. Zero LLM cost — same data path as GET /api/portfolio/:portfolioId. Resolves deployed paper/live portfolios first, then chat portfolios. Use fetch_portfolios to discover IDs. Response includes conditionFieldAudit (comparison, value, window.length per base condition) — use that for Gate-7/Gate-8 deploy verification, NOT strategy.name or condition.name (those may be stale after GA mutation).

Read an optimization/sweep leaderboard by ID. Zero LLM cost — same data path as GET /optimization/:id. When status is COMPLETE, ERROR, or CANCELLED, materializes each ranked variant as an exact ChatPortfolio (chatPortfolioId per row) for backtest/clone deploy. While RUNNING/PENDING, returns stats only (no chatPortfolioId). Returns resolvedParameters, training AND validation statistics together, selectionProvenance (selectedOn / candidatesRankedOnThisWindow / claimStatus), refreshed config labels, and conditionFieldAudit per row (use conditionFieldAudit for deploy verification — NOT condition.name). IMPORTANT: data_mode "validation" (default rank order) returns selection-contaminated metrics — the number the winner was chosen by out of N candidates, not a forward performance estimate. Always read training alongside validation; a candidate that fails in-sample and wins only on validation is a lottery ticket until confirmed via run_walk_forward_study on data the sweep did not rank on. Page through with `page` (10 per page). Optional conversation_id links materialized portfolios to a chat thread.

Describe sweepable axes for a portfolio: applicable scope/field pairs (e.g. Action + TakeProfitPct), default gene templates with example values, authoringControls, and workflow guidance. Zero LLM cost. Call before hand-authoring sweep_config or planning gene_intents for systematic_sweep / run_walk_forward_study.

Load ingested transcript(s) by ID and return full text + metadata as JSON. Zero LLM cost — use when you need the verbatim transcript body. Aurora chat uses Read Transcript (LLM analysis) instead when summarizing or Q&A.

Read a walk-forward study by ID. Zero LLM cost — same data as GET /walk-forward/studies/:studyId. Returns mode, fold calendar, per-fold stats, validation aggregate (when present), adaptiveResult stitched curve/rolls (adaptive/both), and root optimizer id.

List the current user's optimization and sweep runs with filters (status, portfolio, type, date). Zero LLM cost. Use to discover optimization_id values before calling get_optimization_results. Set top_level_only=true to hide walk-forward child jobs.

List the current user's walk-forward studies with filters (status, portfolio, engine_kind, date). Zero LLM cost. Use to discover study_id values before calling get_walk_forward_study_results — the primary path for tracing GA/sweep certification campaigns.

Create and optionally run a v2 walk-forward study (single root optimizer). Zero LLM cost on the tool — charges research tokens once up front unless preview_only=true. For sweep studies prefer gene_intents (or call get_sweep_surface first). preview_only compiles genes and estimates cost without billing. mode: validation (default), adaptive, or both. Requires fold_count (2–8).

Deterministic performance metrics for many portfolios at once: totalReturnPct vs stored initialValue, Sharpe, max drawdown, and excess return vs a baseline (default SPY) computed on the same calendar window as the portfolio history chart (first→last point). No LLM commentary, no positions, no fundamentals. Chat portfolios are silently skipped (ephemeral). Up to 50 portfolio_ids per call — chunk your IDs and call repeatedly if you need more. Use this instead of analyze_portfolios when you only need the numbers across the full portfolio history.

List markdown notepads attached to a deployed portfolio. Zero LLM cost — direct DB read. Use fetch_portfolios first to discover portfolio_id values.

Fetch one markdown notepad attached to a deployed portfolio. Zero LLM cost — direct DB read.

Create a markdown notepad attached to a deployed portfolio. Zero LLM cost — direct DB write.

Update a markdown notepad attached to a deployed portfolio. Zero LLM cost — direct DB write.

Archive one portfolio notepad. Zero LLM cost — direct DB write. Requires expected_version and fails on stale versions. Archived notepads are hidden from owner and shared views.

List immutable versions for one portfolio notepad. Zero LLM cost — direct DB read.

Fetch one immutable version snapshot for a portfolio notepad. Zero LLM cost — direct DB read.

Diff two immutable versions of one portfolio notepad. Zero LLM cost — direct DB read.

Revert a portfolio notepad to an immutable prior version. Zero LLM cost — direct DB write. Requires expected_version and creates a new current version.

Search NexusTrade blog articles by keyword across title, body text, and tags. Returns lightweight hits with match-centered excerpts. Use for deterministic discovery before get_article. For agent-ready strategy context, use nexustrade_article_search.

Fetch the full NexusTrade blog article (HTML + plain text + metadata) by articleId or shortId. Use after search_articles to retrieve full content.

Promote a stored run_compute signal-shaped dataset into a CustomIndicator. Prefer dataset_id from run_compute/get_compute_status; object_key is accepted for back-compat. Rejects generic-shaped datasets and datasets the caller does not own.

List your saved sandbox datasets (id, request, row shape/count, linked indicator). Active only (archived excluded). Paginated via limit/offset — use hasMore/nextOffset; do not re-list the same offset. Use dataset_id with get_dataset or dataset_to_indicator to reuse compute output without re-running. Zero LLM cost.

Fetch metadata + head/tail sample rows for one saved dataset by dataset_id. Zero LLM cost.

List your saved **active** CustomIndicators (id, name, point count, scope, status). Active-only (archived excluded). Paginated via limit (default 50, max 100) and offset — use hasMore/nextOffset to walk pages; do not re-list the same offset. Use this to find an indicator's id to reference in create_portfolio — e.g. after run_compute → dataset_to_indicator, if you no longer have the id. Zero LLM cost.

Soft-delete an owned sandbox dataset (archives the record; Tigris blob kept). Reversible via restore_dataset until the storage reaper grace period. Does NOT delete any CustomIndicator promoted from it. Zero LLM cost.

Typed refresh/update on an EXISTING saved dataset (target each operation by dataset_id, immutable name, or custom_indicator_id). Operations: replaceContent (full JSONL replace; optional cascade to linked CustomIndicator), appendRows (generic: optional dedupe_key; signal: upsert by timestamp+ticker[, row_id] and cascade the SAME linked indicator; use a stable row_id for distinct same-day lots, which are summed into the indicator point), appendSignal, refreshFromSources, promote (create|replace), refreshSignal, restoreVersion (restore retained content as a new forward version), delete (soft-archive). Signal appendRows/replaceContent/restoreVersion can pass point_kind plus aggregate_period when needed to derive and persist omitted availableAt before cascading. promote requires point_kind. Availability declarations are write-time only, never CustomIndicator fields. Pass rows or a user-owned compute_output_object_key. Recurring sync must target the SAME custom_indicator_id; never invent a new indicator each run. Dataset names are immutable; create auto-suffixes on collision; archived names are reusable; restore_dataset auto-renames on clash. Zero LLM cost.

Restore a soft-deleted dataset to the active list when its Tigris blob still exists. Auto-renames the restored row when an active dataset already owns the same name (e.g. wsb-corpus → wsb-corpus-2). Fails cleanly if storage was reclaimed after grace. Zero LLM cost.

Archive an owned CustomIndicator (soft delete — reversible via unarchive_custom_indicator). Fork-safe: subscriber forks keep independent copies; ACTIVE forks pause auto-sync and dependents are notified. If your own active portfolios still reference this id, the call is rejected unless confirm:true (backtests keep resolving). Zero LLM cost.

Restore an archived CustomIndicator to the active list and reactivate PAUSED forks that were paused when the source was archived. Zero LLM cost.

Submit an asynchronous historical backtest for a portfolio over a date range. Set baseline_symbol to match the book — underlying ticker for single-name options (AAPL→AAPL), per-underlying baselines or equal-weight universe B&H for multi-name options; SPY only for broad equity. Returns a backtest ID immediately; poll query_backtest_status, then query_backtest_history (zero-LLM). Aurora may also use Read Backtest for an LLM narrative once complete.

Create a named watchlist of stock symbols for tracking and use in strategies.

Lists your watchlists and symbols from NexusTrade

Rename, replace symbols, or delete watchlists you own

Search and browse publicly shared portfolios from other NexusTrade users, sorted by performance metrics. Optional profileId filters to one creator's public/monetized books (from Search Creators / /p/:profileId).

⚠ COSTS LLM CREDITS — server-side LLM writes + executes SQL against the MotherDuck market DB (returns the generated SQL so you can verify it). **Manual approval required**; do NOT call unless the user explicitly asked for a stock screen / historical price lookup. END-OF-DAY DATA ONLY: it queries daily price tables (e.g. financials.sec_stock_price_metrics / lake.sec_daily_ohlc); pin "latest" screens to `MAX(date)` — that tip is a finalized session, not a live quote. Do NOT use it for 'what is the market doing now' / 'why is X down today' — those need the live web-search news tool. Good for fundamental screening, point-in-time / as-of-date reads, and derived technical indicators (N-day SMA, RoC, drawdown) via window functions, e.g. 'what was ticker X's 50-day SMA and 21-day RoC on YYYY-MM-DD'. The SQL is model-generated — sanity-check returned numbers.

⚠ COSTS LLM CREDITS — server-side LLM summarizes the news. Manual approval required. Search and summarize the latest news articles for specific stock ticker symbols.

⚠ COSTS LLM CREDITS — Web Access search + answer synthesis. Manual approval required. User-facing general web answer with citations — NOT a corpus/knowledge-base lookup. MCP alias search_knowledge_base is legacy; prefer this tool name in new clients. Do NOT use for structured scrapes from specific sites — use web_ingest or collect_web_data.

⚠ COSTS LLM CREDITS — server-side LLM answers help questions. Manual approval required. Get help with NexusTrade-specific features, UI navigation, available tools, and how-to questions.

⚠ COSTS LLM CREDITS (heavy — Exa Agent multi-step web research). **Manual approval required**; do NOT call unless the user explicitly asked for deep research by this tool name. Perform multi-source web research with analysis on any financial, market, or general topic. Returns a comprehensive research report with source URLs.

Deterministic Supadata-only ingest. Pass creator_url (YouTube/TikTok/Instagram/X/Facebook profile or post, Reddit, article) or creator_name with optional platform. YouTube uses Supadata channel API; other platforms use Supadata web map/scrape/crawl for profile batches. Returns content IDs — never full text.

Retrieval over a creator's ingested corpus (scope via creator_channel_id, handle, or source_ids). For dated "when did @handle mention TICKER" / list-every-mention questions: zero-LLM blob scan (reads Source text directly — no index wait) returns a chronological hits table. For semantic/thematic questions about what was SAID: costs LLM credits (async corpus_query_id — poll get_corpus_answer). Ingest first. NOT for: (1) current market facts — use screen_stocks / search_stock_news. (2) numeric aggregation ("how many times") — use run_compute.

Zero-LLM. Aggregates grounded Source annotations from a creator's ingested corpus into a dated numeric series and persists it as a CustomIndicator (lookahead-safe: each row is timestamped at the Source's publish date). Scope via creator_channel_id, handle, or source_ids; ingest first with ingest_content. template is one of ticker_mentions_per_period, share_of_mentions_per_period (requires ticker), or sentiment_per_period. period is day/week/month/quarter. Returns the customIndicatorId and row count.

Open-web discovery for agents. Exa and native web search independently find candidates; preferMachineReadable biases both toward authoritative inventories, archives, downloads pages, and API boundaries. Empty/thin LIVE results auto-deepen once (type=deep). Flywheel mode (source_ids/handle) excludes ingested domains and shapes the query toward similar sources. Liveness is only reachability, not authority. For exhaustive work, describe the semantic record need and inventory artifact. Select a relevant candidate URL and pass it into Run Compute (request text) or queue_fetch in the sandbox. Fetches are SSRF-guarded. Results also include handoff.webIngest for document ingestion. For daily TOPIC recurrence, schedule an Aurora agent to re-run Discover → web_ingest. NOT for answer-style questions (→ General Info V2).

⚠ COSTS LLM CREDITS (3× Grok 4.5 web-search lanes in parallel). Discover social POST and PROFILE URLs for one person/handle. Returns candidates[] + coverage.webIngestBatches (drain ALL; each ≤30 urls with max_items=len) + coverage.requiredProfileIngests (youtube/x REQUIRED ingest_content) + coverage.optionalProfileIngests (best-effort) + handoff.webIngestMcp (batch 0 only). Prefer max_items=urls.length. Do NOT finalAnswer from Grok prose — drain ingest, then ask_corpus with a dated-mention question (Ask Corpus blob-scans for ticker tables; no index wait). Prefer over discover_sources when the job is 'when did @handle say TICKER on socials'.

Probe 1–10 absolute http(s) URLs for liveness (Range GET). Use LIVE results with run_compute; skip DEAD. Reddit URLs are skipped — use web_ingest.

Acquire documents (URL, chat upload via attachment_ids, PDF, image, article, video) into the Source corpus via the modality router, with lookahead-safe dates. CustomIndicator via name= requires exactly ONE url OR ONE attachment_id per call (name= with multiple inputs is rejected). When that single doc is STRUCTURED (filing tables, chart/table OCR) it extracts a signal dataset; pass name="<indicator>" with one input to persist as CustomIndicator (same as run_compute name=), returned as custom_indicator_id. Multi-document history / many filings / aggregate records → run_compute (pass name and point_kind there). Batch urls without name= is corpus-only. dry_run:true inspects routing without extracting. NOT for listing feeds — use web_ingest_sync. NOT for clean CSV/JSON/JSONL chat uploads that are already signal-shaped (use ingest_structured_attachment instead — cheaper, zero LLM, no corpus row).

Q&A over user chat uploads (attachment_ids). Returns prose in chat — no Source row, no sandbox, no CustomIndicator. Vision model for images/PDFs; text preview (headers + sample rows) for CSV/JSON/JSONL/TXT. Use for what is this / explain this screenshot, PDF, or data file. To PERSIST a clean CSV/JSON/JSONL upload as a CustomIndicator use ingest_structured_attachment instead; for structured extraction from PDFs/images into corpus or indicators use web_ingest; for novel compute use run_compute.

Zero-LLM. Parses chat upload attachment_ids (CSV/JSON/JSONL) with the SAME validators as the /custom-data upload flow (rows must already be timestamp/value[/ticker] shaped — no cleanup or transformation). Target the indicator via custom_indicator_id (existing, ownership-checked) or name (creates one if missing — pass scope=global|asset and description on create). mode=append (default) adds rows; mode=replace overwrites the accepted ledger (refused if it would shrink history unless the indicator is brand new). Returns custom_indicator_id, accepted_rows, and any per-row validation errors. Tidy multi-file CSV/JSON/JSONL uploads that are already signal-shaped can be passed together — rows are concatenated. For messy/novel files needing cleanup or arbitrary sandbox computation use run_compute instead; for PDF/image/scanned-table extraction use web_ingest; for plain Q&A about the file use describe_attachments.

Paginate listing_urls[], ingest new child URLs, advance per-listing IngestSyncCursor. Pass drain:true so the server catches up in-process until backlogRemains is false (or drain budget exhausted). If budget exhausted with backlog remaining, do not re-call sync in a loop — still append today's counts from what landed (appendSignal upserts by date+ticker), then finalAnswer noting the sync was partial. await_index defaults true with drain (waits for corpus chunks/annotations). NL→URL cheat-sheet (agent builds URLs; server never parses intent): Reddit top-N → https://www.reddit.com/r/{sub}/top/?t=day&limit={N}; Reddit new feed → …/new/ (pass the full .json feed URL); Reddit search (e.g. WSB Daily Discussion this week) → …/search/?q=Daily+Discussion&restrict_sr=1&sort=new&t=week; open-web index/homepage → listing_urls with the index URL (Firecrawl map discovers same-site child links). Reddit blocks fall back to Jina residential HTML automatically.

Blocking SEC EDGAR tool (zero LLM). action=list_filings returns ranked 10-K/10-Q/8-K rows with archive URLs; action=ingest_filings persists filing text as document Sources (filed date = signal date); action=fundamentals returns inline XBRL metrics. list_filings → confirm → ingest_filings → run_compute/ask_corpus. NOT for open-web discovery (discover_sources) or arbitrary URLs (ingest_content).

Costs LLM credits. Generic per-source enrichment primitive: pass source_id (from ingest_content) and a natural-language instruction describing what structured data to extract from the raw content. Returns whatever JSON shape the instruction asks for — no fixed schema. Use for date recovery, stance scoring, price-target extraction, entity mapping, thesis summaries, or any other single-source extraction the agent composes via the instruction string. Does not mutate the Source; persistence is the caller's concern.

Costs LLM credits. Runs arbitrary Python in a leased Sprite over staged inputs via a stepwise sandbox operator. For a discovered external series, name the Discover Sources candidate URL in the request (or queue_fetch it). Fetches are SSRF-guarded; optionally pass a parent receipt for cookie/lineage continuity on GET. Forms and POST query APIs: GET the page first, then method=POST with that source_receipt (POST confined to the receipt origin). When the user/plan needs complete or multi-period filings/holdings history, do not silently shrink the request to the latest one/two partitions or non-zero deltas only — emit levels across the inventory span (deltas optional). Pass `attachment_ids` (PDFs/images/CSV/JSON/JSONL/TXT) to stage uploads under /work/data/uploads/. Prior Stock Screener results in the same agent conversation are auto-staged under /work/data/screener/ (latest.jsonl + latest.meta.json) — freeze the screener event contract, then join lake prices in compute when needed. Set `create_report: true` for a branded investor-grade PDF from this run (never a portfolio — emit signal datasets and let the agent call create_portfolio / build_portfolio). Pass `name` for signal-shaped rows; `create_report` and `name` compose, so one job can return the PDF and persist the CustomIndicator. If a CSV/JSON/JSONL upload is ALREADY clean and signal-shaped (including tidy multi-file concatenations), prefer ingest_structured_attachment instead — it is zero-LLM and cheaper. MCP returns compute_job_id — poll get_compute_status / cancel_compute_job.

Costs LLM credits. Accepts only request. Finalizes or revises the complete structured report JSON and creates a private branded PDF from already-gathered context. In Aurora, the host resolves the latest report, user attachments, and completed owned backtests from the conversation. It never runs compute; call run_compute first for new analysis.

Resume an interrupted or paused Run Compute job by compute_job_id. Zero LLM.

⚠ COSTS LLM CREDITS — Supadata MCP + structured JSON. Manual approval required. Specific web search for WSB, Medium, creator discovery, disclosures — NOT general Q&A. Returns collectWebDataResult + summary; contentUrls trigger transcript ingest.

Run a genetic algorithm optimization on a portfolio to find the best-performing strategy parameters over a date range. Optional selection_policy applies activity/quality floors to steer away from thin validation winners (never hard-fails). Costs research tokens that scale with the number of evaluated candidates (population × generations × windows), the date range, the interval, options usage, and portfolio breadth. Intraday and options portfolios cost more per candidate (a minute interval is ~3× and an options portfolio ~2× the daily-stock base, and both stack). There is no daily run limit — size population/generations/date-range to the question.

Submit one asynchronous systematic strategy-search optimizer for a portfolio. Prefer this over optimize_portfolio when the user asks to test option deltas, DTE, allocation, top-K, entry/exit filters, rank signals, close-option roll triggers, or RebalanceOption strategy-design surfaces. Auto mode exhaustively evaluates small gene grids and uses generational search for large spaces. Configure num_generations/population_size for generational search; do not call this repeatedly to simulate iterations. Pass portfolio_id plus start/end dates; the server derives a default Rust-compatible sweep config unless sweep_config is supplied. When the user sets a deployment band or participation floor, pass selection_policy with medianDeployment/participationRate/distinctUnderlyingsTraded constraints (medianDeployment as primary minimizes deployment). Costs research tokens that scale with evaluated candidates, date range, interval, options usage, and portfolio breadth (intraday + options cost more per candidate); there is no daily run limit — size population/generations/date-range to the question. Returns an optimization ID; use get_optimization_results after completion (each row includes validation.medianDeployment).

⚠ COSTS LLM CREDITS — server-side LLM writes the analysis prose. For deterministic numeric metrics (Sharpe, drawdown, excess return) with NO LLM, use `get_portfolio_performance` instead. Only call this when the user explicitly asked for LLM-written analysis. Analyze your portfolios with detailed statistics, benchmark comparisons, and fundamental enrichment. Use fetch_portfolios first to discover portfolio IDs.

⚠ COSTS LLM CREDITS — server-side LLM writes the explanation. Manual approval required; do NOT call unless the user explicitly asked for LLM-written order explanations. Explain pending live trading orders, related strategy context, portfolio impact, and recent portfolio events.

Zero LLM cost. List the authenticated user's Order documents filtered by optional portfolio_id and statuses (default: Accepted + Pending User Approval). Paginated like GET /api/order (page + limit; returns total, totalPages, truncated). Returns order IDs for cancel_orders. Optional include_rebalance_orders lists pending rebalances for visibility only (not cancelable via cancel_orders).

Create orders for a LIVE or PAPER deployment portfolio. LIVE orders are created UNAPPROVED (like strategy-generated orders) and are NEVER submitted to a broker by this tool — the user must approve them manually in the NexusTrade UI. PAPER orders are created as accepted paper market orders immediately and do not require manual approval or a brokerage token. Stock/crypto: quantity XOR amount (dollars). Options: contract quantity only (no dollar amount). Multi-leg spreads group legs with a shared spread_group.

Cancel one or more Order documents by order_ids. Same semantics as DELETE /api/order/:id: Accepted or Pending User Approval only; LIVE orders with a broker orderId are canceled at the brokerage then in DB; otherwise DB-only. Multi-leg groups cascade. Partial success allowed. Discover IDs with list_orders first — do not use explain_orders for discovery.

Set share settings on a deployed portfolio (public, specific_emails, monetized, or nobody) and return the shareable URL. specific_emails adds recipients without revoking the existing allowlist, then stages only newly added addresses for your UI approval unless notify=false; optional message is markdown→HTML preview. Nothing is emailed until you confirm. Non-admins limited to 10 successful sends per UTC day. Monetizing requires Stripe Connect onboarding.

Cancels all open orders on the portfolio first (Accepted / Pending User Approval / Pending / Partially Filled — any createdBy), then previews orders for a LIVE or PAPER book. REQUIRED: mode=delta (diff current vs target) or liquidate_all (close every position and go to cash — the target is empty, no Rust resolve, and NOTHING is re-opened; not a cost-basis reset). target_basis is REQUIRED when mode=delta and ignored otherwise: fresh_deploy (NAV cash, empty book — names the strategies would not open today get CLOSED) or current_book (seed existing cash+positions, then today's exits/rebalance; no signal ⇒ holdings unchanged). Never tell the user reconcile is blocked until fills — cancel is the path. Returns target, current, orders (create_orders shape), estimated cost, realized P&L, wash-sale flags, warnings, and canceledOrders. Close+open wash-sale pairs are omitted (kept current; skipped as WASH_SALE_NEGATED). Does NOT place or stage delta orders — hand returned orders to create_orders. Broker cancel failure aborts the tool. Warn when fresh_deploy yields an empty target against a non-empty book.

Typed refresh on an EXISTING dataset (dataset_id, name, or custom_indicator_id). Operations: replaceContent, appendRows (generic OR signal upsert by timestamp+ticker[, row_id], cascading the same indicator; stable row_id preserves and aggregates distinct same-day lots), appendSignal, refreshFromSources, promote (create|replace), refreshSignal, restoreVersion (retained content becomes a new forward version), delete. Signal append/replace/restore may pass point_kind (+ aggregate_period for period_aggregate) to derive durable availableAt; promote requires it. Write-time only, never stored on CustomIndicator. Names are immutable; create auto-suffixes on collision; restore_dataset auto-renames on clash. Zero LLM.

Deploy, undeploy, rename, delete, add/remove/replace strategies, or set deployment frequency on portfolios. **rename** requires a non-empty `name` on the operation. **delete** permanently removes a chat, paper, or live portfolio (archives deployed paper/live books; deleting a chat portfolio also archives linked deployments). Pass confirmLive:true only after explicit user confirmation when deleting an active live portfolio. **Structured path (zero LLM cost):** pass an `operations` array — see inputSchema. Use `replaceStrategy` / `replaceStrategies` with full `{name, condition, action}` strategyObjects (same shape as create_portfolio). RebalanceOption: set `action.positionScope` to `portfolio` (single-book — closes/orphans all option spreads in the portfolio) or `strategy` (multi-strategy book).

Replace a deployed (paper/live) portfolio's entire strategy set with deep copies of a source portfolio's strategy objects (by reference, not YAML). Source is a chat or deployed portfolio; the target MUST be a real deployed portfolio (chat portfolios are immutable and cannot be a target). Use this to deploy a chat portfolio's strategies onto a live/paper portfolio without re-describing them. Do NOT automatically backtest after clone — only backtest when the user asked for research validation. The source's prior backtest does not validate the target (different objects), but deploy-only asks should stop at clone/deploy.

Deep-copy a source portfolio (chat OR deployed) into a NEW chat portfolio, applying RFC-6902 JSON-Pointer patches (op/path/value) so the copy is byte-exact except at the patched paths. Use this — NOT create_portfolio — to fork an existing portfolio and change a few parameters (e.g. book deployment, perNameAllocation, a regime-gate condition), because re-authoring strategies as YAML is a lossy round-trip. Patch paths target the IPortfolio shape and are action-type-specific: DynamicRebalance cash/deploy → `/strategies/0/action/deploymentPercent` (number 0–100); RebalanceOption book budget → `/strategies/0/action/totalBudget/amount`. Never put totalBudget on DynamicRebalance or deploymentPercent on RebalanceOption — validation rejects the wrong field. Requires source_portfolio_id, name, and a non-empty patches[]. Pass dry_run:true to preview the applied diff without persisting. Result is a chat portfolio; backtest it to evaluate.

Replace a deployed (paper/live) portfolio's entire strategy set with deep copies of one exact backtest run from the anonymized corpus, using backtest_uuid as the source handle. This copies exact strategy objects instead of re-describing them. Do NOT automatically backtest after apply — only backtest when the user asked for research validation. Corpus performance does not validate the deployed target object, but deploy-only asks should stop at apply/deploy.

⚠ COSTS LLM CREDITS — server-side image-generation model. Manual approval required. Generate an image from a text description using AI image generation.

Get real-time options chain data for a stock symbol, including pricing, implied volatility, and Greeks.

⚠ COSTS LLM CREDITS — server-side LLM ranks and synthesizes insights. Aurora-agent-only context — only relevant when the user is actively working with prior agent runs. Search insights and learnings saved from past autonomous agent runs, filtered by ticker, strategy type, or keywords.

Search the anonymized backtest corpus with structured facets (tickers, asset class, cadence, indicators, actions) for historical strategy prior art: robust winners, robust failures, and cohort medians for strategy-design hypotheses. Do not use for free-text/name/archetype lookups such as portfolio names, v9 labels, or spread20-buyback14; use screen_backtest_corpus for those.

⚠ COSTS LLM CREDITS — server-side LLM converts NL → SQL. For zero-cost structured corpus search, use `search_backtest_corpus` (faceted filters, no LLM). Only call this when you need NL→SQL translation explicitly. Screen the anonymized backtest corpus with SQL generated from natural language, returning matching backtest rows plus full strategy JSON when backtest UUIDs are selected. Use this for free-text/name/archetype lookups such as portfolio names, v9 labels, spread20-buyback14, Public Portfolio Challenge, or exact corpus row discovery.

⚠ COSTS LLM CREDITS — server-side LLM extracts context from matched articles. For zero-cost article discovery use `search_articles` + `get_article` (pure substring + fetch, no LLM). Only call this when you need LLM-summarized strategy rationale. Search NexusTrade blog articles and use a server-side LLM extractor to turn Austin's published posts into compact strategy rationale, selection criteria, momentum rules, caveats, and citations. Use the explicit top-level schema only: query, queries, objective, tags, and limit. Include query variants when the user names an article family, episode, shorthand number, or strategy label.

Zero-LLM. Returns Polygon's `related-companies` peer-ticker list for a single symbol (sector + business-similarity peers — e.g. AAPL → MSFT, GOOGL, AMZN...). Use when the user asks for stocks similar to / competitors of / peers of a ticker. Pure structured-schema tool: no NL parsing, no LLM credits. Pairs well with `screen_stocks` (further filter the returned peers by fundamentals) or `search_stock_news` (recent news on the peers).

Zero-LLM. Search public-profile users (creators) by display-name/description keyword with optional sort and page. Returns { creators, total, page, limit, query }. Use when the user asks to find, discover, or browse creators or investors.

Zero-LLM. Load a single creator's public profile fields plus their shared portfolio performance summaries. Requires profileId (string slug from the creator's URL or search_creators). Returns { creatorProfile: { displayName, description, investmentThesis, sharedPortfolios, isVerifiedCreator, ... } }.

Zero-LLM. Follow or unfollow a public-profile creator. action: 'follow' | 'unfollow'. For private profiles, follow sends a follow request. Returns { followCreatorResult: { status, profileId, displayName } } where status is 'following' | 'friends' | 'requested' | 'not_following'.

Zero-LLM. Add, remove, or toggle a bookmark on a shared portfolio. action defaults to 'toggle'. Returns { bookmarkPortfolioResult: { isBookmarked, sharedPortfolioId, name? } }.

Zero-LLM. Return all shared portfolios the authenticated user has bookmarked, enriched with SharedPortfolioPerformance data when available. Returns { bookmarkedPortfolios: [...], total }. Use when user asks 'show my favorites', 'bookmarked portfolios', or 'saved strategies'.

⚠ MUTATING — checkout handoff. Validates monetized access and returns a checkout preview; the UI creates a fresh authenticated Stripe Checkout session only when the user clicks. NEVER completes payment in-process. Returns alreadySubscribed:true if already subscribed, or { needsCheckout:true, fee, portfolioName, owner } otherwise. Ask the user to confirm intent before calling.

⚠ MUTATING — creates or modifies a portfolio. Fork strategies from a shared portfolio into the user's account. target: 'new' creates a chat portfolio; 'existing' patches a deployed portfolio. mode: 'replace' (default) removes old strategies, 'append' keeps them. For monetized portfolios, subscribe first. Returns { forkSharedPortfolioResult: { portfolioId, name, addedCount, removedCount, ... } }. Prefer fork when the user wants to edit/customize strategies.

⚠ MUTATING — creates or modifies a portfolio + live/paper trading. Mirror a shared portfolio at a percentage allocation. mode: 'new' creates a new portfolio; 'existing' links an existing one. active applies to newly created portfolios; for an existing live target, ask the user to confirm the portfolio explicitly. percentOfPortfolio is required (>0 and <=100). Returns { copyTradeSharedResult: { portfolioId, portfolioName, percentOfPortfolio, isNew, active } }.

Zero-LLM patch to the authenticated user's own creator profile. Patchable fields: displayName, description, investmentThesis, visibility, socialLinks (object), experience, goals, pinnedSharedPortfolioIds, pinnedWatchlistIds. All fields are optional — omitted fields are preserved. No avatar support. Returns { updateCreatorProfileResult: { profile, profileUrl } }.

Zero-LLM submit (or resubmit after rejection) of the authenticated user's creator monetization application. Required: first_name, last_name, years_of_experience (0-100), strategy_description (>=50 chars). Optional: linked_in, instagram, youtube, tiktok. Two-step by design: without confirm_submission:true this writes nothing and returns { applyForCreatorConfirmation: { requiresConfirmation, submission, howToProceed } } echoing the exact values — show them to the user, get explicit approval, then re-call with confirm_submission:true. These are the user's real identity details submitted to a human reviewer; never infer or invent them. Confirmed calls return { applyForCreatorResult: { status, approvalRequestId, creatorApplyUrl } }. After approval + Stripe Connect, retry share_portfolio to monetize.