Valuein — SEC EDGAR Fundamentals & Smart-Money Data

Approve a staged action by id and RUN the underlying tool call it proposed, using the caller's own current credentials — never the original proposer's. Idempotent and race-safe: an action already decided (approved by a concurrent call, rejected, executed, or failed) is NEVER re-executed — this returns the action's current state with `executed_now: false` instead. On a fresh approval, `executed_now` is true and `tool_result` carries the underlying tool's own structured result, exactly what a direct call to that tool would have returned. If the underlying tool itself fails, the staged action transitions to 'failed' with a `reason` — this call still succeeds (the approval + execution ATTEMPT is what it promises; a failed underlying write is a normal, inspectable outcome, not a tool error). An id belonging to a different customer's token is indistinguishable from an unknown id (returns NOT_FOUND) — ownership is never leaked. Tier: sp500+ (sample rejected).

Cancel a pending scheduled task by id (from schedule_task or list_scheduled_tasks). Only a `pending` task can be cancelled — one that already woke (completed) cannot be un-woken. Idempotent: cancelling an already-cancelled task is a no-op. Undoable: `restore_deleted` with kind `scheduled_task` and this task_id re-queues it while its wake time is still in the future and the tier cap has room. Tier: sp500+ (sample rejected).

Compare a company's core financial metrics across two fiscal periods side-by-side. Shows absolute and percentage changes with significance classification (minor < 5%, notable 5–15%, significant > 15%). The response includes a `material_changes` count: this is the number of metrics whose `significance` ∈ {notable, significant} (i.e. absolute percentage change > 5%). Use it as a quick scalar to triage filings — anything > ~3 typically signals a material event worth deeper review. Use period format: 'FY2024' for annual, 'Q1-2024' for quarterly. Pass `period_a` as the EARLIER period and `period_b` as the LATER one — if you invert them the server auto-swaps and sets `swapped: true` in the response so deltas always carry the correct sign (rather than silently flipping). Point-in-time safe via as_of_date. Available on all plans.

M&A accretion/dilution: the standard sell-side/banker quick-screen for whether a proposed acquisition adds to (accretive) or subtracts from (dilutive) the acquirer's EPS in the first pro-forma year. Pulls net income + shares outstanding for both companies, and each side's latest EOD close (acquirer's price converts stock consideration into new shares issued; target's price is used only to disclose the offer premium). Caller sets the consideration mix (cash_pct, cash-financed by new debt or the acquirer's balance sheet), annual run-rate synergies, and the new-debt interest rate. A SINGLE pro-forma-year bridge — NOT a multi-year merger model; synergy ramp, integration costs, and purchase-price-allocation amortization (goodwill/intangibles step-up) are not modeled (see `result.caveats[]`). `result.accretion_dilution_pct` positive = accretive, negative = dilutive. Tier: sp500+.

Forward discounted-cash-flow valuation (two-stage Gordon-growth model): caller provides growth + WACC + terminal assumptions, returns per-share intrinsic value (`value_per_share_cents`, cents USD) + 5×5 sensitivity grid. Pulls FCF base + net debt + shares from R2; caller can override any field. Definitions (consistent with `get_financial_ratios` / `get_capital_allocation_profile`): FCF base = operating_cash_flow − capex (absolute USD); net_debt = total_debt − (cash + short-term investments). Shares resolve via a fallback chain (valuation row → fact CommonSharesOutstanding → net_income/eps_diluted), reported as `result.shares_source`. The pulled inputs are echoed in `result.inputs_echo` with their source lineage so the valuation is reproducible and traceable. A null `value_per_share_cents` means the model is degenerate (e.g. WACC ≤ terminal growth, or FCF base ≤ 0) or a required input was unavailable — it is NOT a zero valuation; the `reason` field explains. Use the returned figures exactly. Use this when you want to drive the assumptions yourself; for the pipeline's pre-computed DCF/DDM value and inputs (no assumptions needed) use `get_valuation_metrics` instead. Does NOT persist a report — use `create_report` (report_type:'reverse_dcf') for that. `fcf_source` (default "trend"): "trend" compounds a single FCF base by `stage1_growth_rate` every year (the original behavior, unchanged). "three_statement" instead runs a full linked Income Statement / Balance Sheet / Cash Flow projection (`project_three_statement`'s engine) and feeds its year-by-year FCF stream into the same PV math — `stage1_growth_rate` is then ignored (kept for echo only) because revenue growth + margins drive FCF instead of a flat compounding rate. The projection detail (including per-year `tie_out_ok`) is returned in `three_statement_detail` when used. Tier: sp500+.

Leveraged buyout returns analysis: caller provides entry/exit multiples, leverage, and a hold period; the tool builds a Day-1 pro-forma opening balance sheet from the deal's own sources & uses (cash-free, debt-free convention — entry_debt = leverage_multiple x EBITDA, sponsor_equity = entry_enterprise_value + minimum_cash - entry_debt), then runs it through the same linked three-statement engine as `project_three_statement` (100% FCF-to-debt-paydown sweep by default). Returns MOIC and IRR (solved by bounded bisection over the sponsor's cash flow stream — interim dividends if any, plus exit equity proceeds). EBITDA is PROXIED by operating income (no separate D&A concept exists in the dataset) unless entry_ebitda_override is supplied — see `result.entry_ebitda_is_proxy`. `result.irr.converged:false` means no root was found (e.g. a total wipeout) — never a fabricated rate. Every simplification is listed in `result.caveats[]`. Tier: sp500+.

Synchronously generate a research report and persist it under the caller's authorship. Two subtypes: • `reverse_dcf` — solves the stage-1 free-cash-flow growth rate the market price implies, with a 5×5 sensitivity grid across WACC × terminal-growth assumptions. Returns full markdown + structured JSON + every numerical claim's citation chain to the originating SEC accession. • `thesis` — snapshot a saved thesis (via `save_thesis`) as a frozen narrative report with at-a-glance table, author notes, anchor fundamentals (latest annual), and lineage to the source filing. Later edits to the thesis do NOT propagate — generate a new report to capture new state. Tier: sample tier rejected — reports are per-author state.

Persist a trigger -> action rule and register it with the evaluator. 7 trigger types accepted (alert_fired, schedule_tick, inbox_item, price_threshold, filing_event, manual, scheduled_task_wake) x six action types (run_team, send_alert, create_report, score_thesis, schedule_task, post_inbox). These trigger types have a live event source and DO dispatch today: alert_fired, schedule_tick, inbox_item, filing_event and scheduled_task_wake. price_threshold and manual are accepted and persisted (forward-compatible schema) but have NO live event source wired yet, so a rule created with one of them is saved as enabled:true and simply never fires. Always read the returned rule's `trigger_wiring_status` field ("live" vs "not_yet_wired") — it is computed from the dispatcher's own registry, so it is authoritative even if this description is stale. `condition_expr` is an OPTIONAL single comparison (`"field op value"`, op one of gt/gte/lt/lte/eq, e.g. `"price_change_pct gt 5"`) evaluated against the trigger event's payload — omit to fire on the trigger alone. Deliberately NOT a general expression language (no AND/OR, no loops) — this is both an anti-complexity and an anti-loop guard; compose multiple rules if you need more than one comparison. Use `test_rule` immediately after creating to verify it fires as expected WITHOUT spending a real dispatch. Tier: sp500+ (sample rejected).

Persist a signal and register it with the firing pipeline. Five condition shapes: * `filing_event` — fire when a ticker files a chosen form type (8-K, 10-K, etc.). * `ratio_threshold` — fire when a ticker's financial ratio crosses a threshold (e.g. interest_coverage < 1.5). * `watchlist_change` — fire when any ticker in a named watchlist files; takes the same optional `forms` filter as `filing_event`. * `price_move` (Pro+) — fire when a ticker's close-to-close move over 1/5/21 trading days crosses a percent threshold in a given direction. * `fundamental_change` (Pro+) — fire when a standard_concept reports a brand-new period or gets restated. Delivery channels: `email` (for `filing_event` / `watchlist_change` this is the MORNING DIGEST — every filing matched since the previous digest, each with its SEC link, in one email at the customer's local 7am; for the other conditions a transactional email at most ONE per signal per UTC day, further matches that day landing in the in-app inbox), `webhook` (HMAC-SHA256-signed POST), `slack` (hooks.slack.com incoming webhook), `dashboard` (in-app inbox), or `agent_run` (runs a standing agent and delivers the finished artifact to your inbox; the run itself bills to the owner's own AI key or prepaid balance). Pass ONE channel as `channel`, or several (up to 4, distinct) as `channels` — e.g. inbox AND email. The cron evaluator runs every 5 minutes. Use `test_signal` to verify your channels are wired correctly before relying on the cron.

Delete one of the caller's own standing agents by id. Undoable: `restore_deleted` with kind `agent` and this agent_id brings it back as it was (enabled or paused). System agents (is_system:true on get_agent/list_agents — built-in agents the platform provisions) cannot be deleted and are rejected with a clear message. Idempotent in effect: deleting an already-deleted or unknown id returns NOT_FOUND. Tier: sp500+ (sample rejected).

Forget ONE durable memory entry by key — use it when a note you stored is now wrong, superseded, or was only ever scratch. Every entry is re-read into your context at the start of every future run, so leaving a stale one behind means re-grounding yourself in something false; deleting is the correction. Idempotent: deleting a key that is not there returns deleted:false, not an error. Also how you free a slot when the 200-entry cap is reached. Undoable: `restore_deleted` with kind `agent_memory` and this key brings the note back (unless you have written that key again since). This removes only YOUR memory note — it never touches a thesis, claim, report, or any financial fact. Tier: sp500+ (sample rejected).

Remove a user-authored citation correction by fact_id. Idempotent — deleting a missing override returns deleted=false without error. UNDOABLE: restore_deleted with kind 'citation_override' brings it back (unless a new save for the same fact_id replaced it). Once deleted, reports that previously rendered the corrected value revert to the canonical fact value on next regeneration. Tier: paid + free (sample rejected).

Soft-delete a claim by id. The row and its score history are preserved for audit (archived, not erased); the claim drops out of default list_claims results. Idempotent — deleting an already-archived claim succeeds. Tier: all paid + free tiers (sample rejected).

Soft-delete a report owned by the caller: status flips to `delisted`, visibility to `private` — not a hard delete, the row and R2 artifact are preserved (90-day audit window). Idempotent (deleting an already-delisted report succeeds). Sample tier rejected.

Delete a rule by id (from create_rule/list_rules) — hides it from the catalog and removes it from the evaluator's scan index, so it stops firing immediately. UNDOABLE: restore_deleted with kind 'rule' brings it back and resumes evaluation (subject to the signal cap). Rules are immutable — to change one, delete then create_rule. Idempotent. Tier: sp500+ (sample rejected).

Soft-delete a signal by its id (from create_signal/list_signals): status flips to `deleted` and it is removed from the cron evaluator index so it stops firing. Signals are immutable — to change one, delete then create_signal. Idempotent. Tier: sp500+ (sample rejected).

Soft-delete a saved thesis: status flips to `archived` (the row stays for audit / re-scoring). Idempotent — archiving an already-archived thesis succeeds. Hard-delete is not supported by design; future versions may expire archived theses after N years. This does not delete the claims linked to the thesis — use delete_claim for those. Tier: paid + free (sample rejected).

Delete an uploaded document before its 24h TTL. UNDOABLE: restore_deleted with kind 'uploaded_document' brings it back while it is still within its 24h TTL and its file exists. Deleting a missing/already-expired/foreign id returns deleted:false rather than an error.

Soft-delete a watchlist by its name (not id): status flips to `archived` (still readable via list_watchlists status=all/archived). The name is freed for reuse by a new save_watchlist. Idempotent. Tier: sp500+ (sample rejected).

Returns the Parquet schema for all tables in the Valuein SEC data warehouse. Includes table descriptions, column names, types, primary keys, and foreign-key references. Use this tool to understand the data model before querying with other tools. No data reads required — schema is embedded in the manifest. Available on all plans.

Soft-delete a single inbox item by its id (from list_signal_inbox) — not a signal id; sets `dismissed_at`. The row stays queryable via `list_signal_inbox(include_dismissed=true)` for audit. Undoable: `restore_deleted` with kind `inbox_item` and this inbox_id un-dismisses it. Idempotent. Tier: sp500+ (sample rejected).

Deterministic forensic-accounting scores for a single ticker: partial Beneish M-Score, Sloan accruals, and a solvency snapshot. Returns a red-flag narrative ranked by severity, with citations to source filings. Used by the `forensic_earnings_brief` SOP. Note: full Beneish needs AR / current assets / PPE / SGA / current liabilities, which aren't in our fundamentals model. We compute the recoverable subset (SGI + TATA + LVGI) and flag `partial=true`. Tier: sp500+.

Render a peer comparables table into an Excel workbook. The Comps sheet is formatted as a named Excel Table (`ValueinPeerComps`) so the user gets one-click Insert Chart on any column — the cleanest workaround for not embedding chart objects server-side. Subject-row highlight makes side-by-side comparison instant. A Summary sheet adds subject vs peer-median deltas. SERVER-TRUST: the ratios you pass are rendered as-supplied and are NOT re-derived by Valuein, so the workbook carries a visible 'figures supplied by caller, not verified by Valuein' watermark (response `verification.status` = 'unverified'). For authoritative numbers, source them from `get_peer_comparables` / `get_financial_ratios` first. Pair with `get_peer_comparables` for a typical flow. Tier: pro+.

Render a forward DCF result into a professional Excel workbook (Summary + 5×5 Sensitivity heatmap + Inputs sheet). Native conditional formatting — no chart images needed. Returns a 15-minute presigned R2 download URL. SERVER-TRUST: the DCF is re-derived in-Worker from the supplied `inputs_echo` (the math is pure + deterministic) and the workbook renders Valuein's recomputed figures — never the caller's claimed values. If the claimed figures disagree, the workbook is still produced but stamped with a visible correction banner and the response `verification.status` is 'corrected'. A fabricated per-share value can never appear as Valuein-authoritative. Pair with `compute_dcf` for a typical analyst flow: agent calls `compute_dcf({ticker, ...})`, then passes the structured result straight to `generate_dcf_xlsx({ticker, dcf_result, ...})` to materialise a shareable file. Tier: pro+.

Render an LBO result into a professional Excel workbook (Summary + year-by-year Projection table + Inputs sheet). Returns a 15-minute presigned R2 download URL. SERVER-TRUST: the deal is re-derived in-Worker from the supplied `lbo_result.inputs_echo` (the math is pure + deterministic) and the workbook renders Valuein's recomputed figures — never the caller's claimed values. If the claimed figures disagree, the workbook is still produced but stamped with a visible correction banner and the response `verification.status` is 'corrected'. Pair with `compute_lbo` for a typical flow: agent calls `compute_lbo({ticker, ...})`, then passes the structured result straight to `generate_lbo_xlsx({ticker, lbo_result, ...})` to materialise a shareable file. Tier: pro+.

Render a structured research brief into a professionally-styled Word document — a branded masthead-first page (Valuein letterhead: brand rule, wordmark, 'EQUITY RESEARCH' kicker + date, then the ticker eyebrow, the title as hero, and the named analyst's byline), the body (abstract, optional snapshot table with figures in mono, markdown sections incl. GFM tables, and a citations table with clickable SEC EDGAR links), with a running footer (ticker, 'Built on Valuein · valuein.biz', page number, a single disclosure line) repeated on every page. No embedded charts in v1; pair with `generate_dcf_xlsx` / `generate_comps_xlsx` for visuals the analyst pastes in. SERVER-TRUST: prose, snapshot rows, and citations are rendered as-supplied and are NOT verified by Valuein, so the brief carries a visible 'figures supplied by caller, not verified by Valuein' watermark (response `verification.status` = 'unverified'). Resolve each citation via `verify_fact_lineage` before publishing. Consumes the same `sections` + `citations` shape `create_report` emits, so the typical flow is two tool calls: `create_report` → `generate_research_brief_docx`. Tier: pro+.

Fetch full detail for one of the caller's own standing agents by id (from save_agent/list_agents). Returns `found: false` (not an error) for an unknown id OR an id belonging to another customer — there is no distinguishing signal, by design, matching get_agent_run's posture. Tier: sp500+ (sample rejected).

Recall this user's durable memory. Omit `key` (or pass null) to read EVERYTHING you have remembered, newest-first — do this at the START of a task to re-ground yourself. Pass a specific `key` to fetch one entry. An absent key returns an empty list, never an error (absence is a first-class answer). Tier: sp500+ (sample rejected).

Fetch full detail for one of the caller's own standing-agent runs by id (from list_agent_runs) — status, goal, tickers, cost, artifact ids, role breakdown, and any error. A run may have been triggered by this same agent or by the customer's own Workspace; this tool works either way. Returns `found: false` (not an error) for an unknown id OR an id belonging to another customer — there is no distinguishing signal, by design. Tier: sp500+ (sample rejected).

Returns SC 13D / SC 13G blockholder disclosures (5%+ stakes) for a US public company. Each row carries percent_owned, sole/shared voting + dispositive split, schedule_type, and the first-class ``going_active`` flag — TRUE when the same filer flipped 13G → 13D within the lookback window (the single most actionable activist signal in this dataset). Use latest_only=true (default) to dedupe to the most recent filing per filer. Use collapse_groups=true to fold multi-person filings into one row. Institutional tier only.

Get a multi-year capital allocation breakdown for a US public company. Shows how management deploys cash across all six categories — capex, R&D, M&A, dividends, buybacks, and debt — plus pre-computed deployment ratios (% of operating cash flow) and over-distribution flags. Use this tool when the user asks: how does a company allocate capital, what's the buyback-vs-dividend mix, is the company over-distributing, is growth funded by R&D or M&A, what's the cash-return-ratio trend, or any 'where does the money go' question — including owner-earnings (Buffett-style) and reinvestment-rate (Damodaran-style) analysis. Data sourced from annual 10-K filings; PIT-safe via as_of_date. R&D is included as a deployment category (the primary growth-reinvestment vehicle for knowledge-economy firms), but since it's already deducted before operating cash flow, `rd_pct_ocf` is INFORMATIONAL and `total_deployment_pct_ocf` EXCLUDES R&D to preserve the cash-flow identity (OCF = capex + M&A + dividends + buybacks + debt repayment + Δcash). The `flags` object carries pre-computed booleans: `buybacks_exceed_fcf`, `total_returns_exceed_fcf` (buybacks + dividends > FCF), and `debt_funded_distribution` (over-distribution funded by leverage vs cash). Available on all plans.

Fetch a single claim by id, plus the ids of theses it supports/refutes and its full append-only score history. Use this to inspect a claim's evidence, current status, and how its outcome has evolved. Tier: all paid + free tiers (sample rejected).

Retrieve standardized SEC EDGAR fundamental financial metrics for a US public company. Returns revenue, gross profit, operating income, net income, EPS (diluted), total assets, total liabilities, stockholders' equity, cash & equivalents, total debt, operating cash flow, and capital expenditures for one or more fiscal periods. Data sourced from 10-K (annual) and 10-Q (quarterly) filings. Point-in-time: no look-ahead bias — pass `as_of_date` (YYYY-MM-DD) to reconstruct exactly the information set known on that date. This returns the raw as-reported line items ONLY. Do NOT derive metrics from them yourself — a hand-computed figure carries no fact_id and cannot be verified against a filing. Every derived metric is already served pre-computed WITH provenance: free cash flow, FCF margin, margins, ROE/ROA/ROIC, leverage and the price multiples come from `get_valuation_metrics`; the full ratio table (incl. per-share, owner-earnings, growth) from `get_financial_ratios`; intrinsic value from `compute_dcf`. If one of those is gated on your plan, say so and offer the upgrade — never substitute your own arithmetic.

Returns a short-lived (15-min) download URL for a bulk Parquet object that can be piped directly into Python/DuckDB/Polars for high-throughput computation that exceeds the MCP context window. The URL streams the object straight from Valuein storage and supports HTTP range reads, so `duckdb.read_parquet(url)` / `pl.read_parquet(url)` work without downloading the whole file first. Datasets: fact (per-entity partition — requires ticker), ratio (all computed ratios, including the 'valuation' ratio category — price multiples, graham_number, ncav_per_share), filing (SEC filing metadata), references (company universe), index_membership (historical index composition). The standalone 'valuation' TABLE was removed (2026-09-14) — use compute_dcf for intrinsic value. Scoped to the caller's tier bucket; the link is signed and cannot be used to list the bucket or read other objects.

Reported earnings results and a model-derived earnings-trend signal for a company, by fiscal period: actual reported EPS, a trailing-trend EPS estimate (`eps_trend_est`), the deviation of actual vs that trend (`eps_surprise_pct`), reported revenue, and year-over-year revenue growth. IMPORTANT: `eps_trend_est` is NOT Wall Street analyst consensus — Valuein is sourced purely from SEC EDGAR and carries no consensus feed. It is a deterministic estimate computed from the company's own prior reported EPS, so `eps_surprise_pct` measures how far the print landed from its own trailing trend, not whether it 'beat the Street'. Use it to track earnings/revenue trajectory and momentum, not to claim a consensus beat or miss. Point-in-time safe — pass as_of_date to filter by SEC acceptance (accepted_at) for look-ahead-free backtests. Available on all plans.

Get pipeline-computed financial ratios from ratio.parquet. Served categories: profitability (margins, ROE, ROA, ROIC), liquidity (current ratio, quick ratio), leverage (D/E, interest coverage, net debt/EBITDA), efficiency (asset turnover, inventory days), per_share (EPS, BVPS, FCF/share), owner_earnings (Buffett FCF, owner yield), valuation (pe_ratio, pb_ratio, ev_ebitda, market_cap, dividend_yield), and the pipeline-emitted forensic, growth, and rank (cross-sectional *_sector_pctile) categories. NOT every category exists for every ticker — omit `categories` to get whatever this ticker has, or read `available_categories` in the CATEGORY_NOT_AVAILABLE envelope. valuation is LIVE (schema 2.18.0): price-derived multiples from EOD prices period-end-aligned — pipeline-derived, NOT strictly PIT (no accepted_at column on these rows). Includes TTM rows alongside annual; each row's `is_calendar_aligned` is TRUE only when period_end sits on the fiscal-year boundary (±7 days) — filter to TRUE when joining ratios to fact-table fundamentals on (entity, fiscal_year). For historical cuts use `as_of_date` (PIT by accepted_at when present, else by period_end — see the param). Use this *instead of* `get_valuation_metrics` when you only need ratios (no DCF wiring); use `get_valuation_metrics` when you also need DCF/DDM. Each ratio is a `{value, unit, category, reason}` entry with a response-level `lineage` (DerivedLineage) pointing to `get_company_fundamentals` / `verify_fact_lineage` for filing-level provenance; a null value carries a `reason` (e.g. INPUT_MISSING) so missing is never a real zero. Available on all plans.

Role-weighted insider sentiment score on a fixed [-100, +100] scale for a single issuer over a lookback window. Role weights: CEO/CFO = 3.0 (via officer_title pattern), other NEO Officer = 2.0, 10%-Owner = 1.5, Director = 1.0. P = +1, S = -1; option exercises, grants, and tax withholdings are neutralised. Cluster flag = TRUE when ≥3 distinct insiders transacted within any 30-day window inside the lookback. Institutional tier only.

Form 3 / 4 / 5 / 144 line items for a US public company. Returns each transaction (or initial holding / proposed sale) with the insider's name, role, transaction code, share count, price, and notional. Filters by lookback window, transaction code (P=purchase, S=sale, A=grant, M=option exercise, F=tax withholding, etc.), insider role, and minimum share threshold. Institutional tier only — sample / sp500 / pro return ENTITLEMENT_DENIED with an upgrade link.

Returns top-N institutional holders of a US public company at a specific period_end (latest by default), with aggregate institutional shares, total market value, holder count, and HHI concentration (sum of squared share-of-total percentages). Sourced from Form 13F-HR via the by-issuer partition. Institutional tier only. 13F filings carry a ~45-day reporting lag — staleness_warning fires when latest data is older than 90 days.

Returns a 13F filer's full portfolio at a specific period_end (latest by default), with QoQ deltas vs the prior quarter (new / increased / decreased / exited / unchanged). Specify the filer either by filer_cik (preferred) or filer_name (fuzzy match against entity.name; multiple matches raise an ambiguity error so you can disambiguate by CIK). Institutional tier only.

Read the caller's Morning Brief — a daily AI-generated market digest covering overnight moves across the customer's own watchlists and theses, produced by the Workspace. Omit `day` to get the most recent brief available (not necessarily today's); pass a specific `day` (YYYY-MM-DD) to fetch that day's brief. It is normal for no brief to exist yet if the customer hasn't set up or recently generated one — that returns `found: false`, not an error. Tier: sp500+ (sample rejected).

Get ratio-based peer comparison for a company and its closest competitors. Peers are selected by matching 2-digit SIC industry code. Returns pipeline-computed ratios from up to 10 peers alongside the subject company for direct benchmarking. Ratio categories: profitability, liquidity, leverage, efficiency, per_share, owner_earnings, valuation. TTM (trailing twelve months) ratios are used when available for the most current view. The exact 4-digit code is matched first, then the 3- and 2-digit groupings, with S&P 500 members first within each. Each company appears once, under its main listed share class; a candidate with no figures for the period is left out and counted in peers_omitted_no_data. Without as_of_date, peers are companies listed today. With as_of_date, peers are companies listed on that date — including ones delisted since — ranked by S&P 500 membership on that date, and figures are limited to that date: by SEC acceptance time when the ratio data carries it (_meta.pit_safe=true), otherwise by period end (_meta.pit_safe=false). Available on every plan — sample returns the subset covered by the sample bucket.

Use this tool to answer questions about historical index membership — e.g. "Was Company X in the S&P 500 on date Y?" or "Which companies were in the Russell 2000 on 2010-01-01?" Use this INSTEAD OF `search_companies` when the question involves a specific historical date or whether a company was an index member in the past — `search_companies` only returns current membership and cannot answer historical questions. Returns a survivorship-free universe valid on a given as_of_date (only companies that existed and were members on that exact date — no hindsight; [) interval semantics). To check one company, pass its ticker or CIK + the target date: present = was a member, absent = was not. ⚠️ HISTORICAL DEPTH AND PROVENANCE DIFFER BY INDEX — read this before using a result for a backtest. • **SP500 — back to 1996-01-02, `high` confidence.** Curated entry/exit spells over 968 CIKs including long-delisted registrants, dated to the actual effective day. • **RUSSELL1000 / RUSSELL2000 / RUSSELL3000 — back to 2000-09-30, `medium` confidence.** Reconstructed from publicly disclosed portfolio holdings of large funds that track each index, not from the index provider's own constituent list (which is licensed). Three consequences you must carry into any conclusion: OBSERVATION SPACING VARIES — roughly one to four observations a year from 2000 through 2006, monthly from 2007 on — so a join or leave date is only as precise as the interval between observations and is never exact to the day in the early years; a tracking fund only PROXIES its index, so a few holdings sit outside the index and a sampled fund can miss some members; and there is NO data before 2000-09-30 — an earlier as_of_date returns zero rows because we do not carry it, which is not a statement that the index was empty. • **Known gap: 2016-12-30 → 2017-07-31.** No holdings observation exists anywhere in that 213-day window, so Russell membership cannot be observed inside it. Departures collapse onto 2016-12-31 and arrivals onto 2017-07-31, which means the June 2017 reconstitution appears to happen on 31 July. Treat Russell results dated inside that window as interpolated. Returns per company: CIK, ticker, name, sector, industry, SIC code, `enriched`, and per-row confidence (high/medium/low). The CIK is always present and is the identifier to carry forward; every other identity field is nullable. `enriched: false` means index_membership names this member but the company has no row in `references` (it delisted before SEC's current-only ticker map was written) — its identity is UNKNOWN, not absent, and it is still a member. `ticker` is separately null when the company was not listed under any ticker on the as_of_date. ⚠️ A RESPONSE IS USUALLY A PAGE, NOT THE UNIVERSE. `universe_size` always reports the FULL matched membership count; `returned_rows` reports what THIS response carries; `complete` is true only when they are equal, and `survivorship_free` is true only when `complete` is — a slice of a universe is not a survivorship-free universe. Two things shorten a response and they need different fixes: `limit` defaults to 100 (smaller than every index here), so raise it toward the index size — `limit_truncated` says when that is what bit; and at most 250 rows are inlined per call whatever your limit, so page with `offset` using the `truncation` envelope's `next_offset` until `returned_rows` sums to `universe_size`. To get the whole universe in one read, use get_compute_ready_stream, the Python SDK, or the Bulk Data API. Index rows are ordered by CIK — deliberately uncorrelated with whether a company survived to today, so a truncated page is an arbitrary sample rather than a list of survivors. `_meta.pit_safe` is true only when EVERY matched row is high-confidence — so it is false for any Russell query by construction. That flag is the one to branch on: use SP500 for rigorous point-in-time work, and treat Russell history as approximate. `sector` is SIC-derived (GICS-aligned, not licensed GICS) — a screening bucket, not an authoritative label. Use as the first step of a quantitative backtest before `get_compute_ready_stream`. Returns an empty array (with error detail) if the date is out of range or has no coverage. Available on every plan — sample returns the subset covered by the sample bucket.

Current and historical valuation multiples for a company. Omit `as_of_date` and it returns today's P/E, P/S, P/B, EV/EBITDA, EV/Revenue and FCF yield, computed from the latest EOD close and the latest TTM financials. Use it for any "what is X's P/E " / "how is X valued right now" question — never derive a multiple yourself by dividing a price by an earnings figure; that is exactly the arithmetic the provenance contract forbids. Pass `as_of_date` to get the same snapshot on a specific historical date — zero look-ahead bias (the 'Compustat + CRSP merge' pattern). The EOD close is sourced from stock_price_daily.parquet at `as_of_date` (or the nearest prior trading day), and all financial figures come from SEC filings with accepted_at ≤ as_of_date so no future information is used. TTM financials are computed by summing the four most recent standalone-quarter values (or using the most recent FY filing when no quarterly series is available). Returns: price snapshot (close, price_date, is_exact_date_match), TTM P&L (revenue, gross_profit, operating_income, EBITDA, net_income, OCF, CapEx, FCF), balance sheet snapshot (shares, cash, debt, book equity), derived market values (market_cap, enterprise_value), valuation multiples (P/E, P/S, P/B, EV/EBITDA, EV/Revenue, FCF yield %), and TTM margins (gross, operating, net). Use for: historical valuation screens, backtesting entry-point multiples, forensic audit of peak / trough valuations, comparing a company's current multiples to its own history. Pro and Institutional only — full = all companies & full history, pro = all companies & last 15 years. On the free plans this tool returns an ENTITLEMENT_DENIED upgrade envelope (required_plan 'pro') BEFORE any read: the EOD close it needs comes from the daily price series, market data the free tiers do not carry. Every plan still has the multiples at each fiscal year end via get_financial_ratios (category 'valuation') and get_valuation_metrics.

Daily EOD bar series (OHLCV) for a company over a date range. Returns up to 252 trading-day bars oldest-first — one bar per trading day. Each bar carries: open / high / low / close (raw, unadjusted), total_return_index (dividends reinvested and splits neutralized, forward-compounded from an arbitrary base so only RATIOS of it are meaningful — TOTAL RETURN BETWEEN TWO DATES IS tri_b / tri_a - 1; it is PIT-immutable, so a later dividend appends rather than restating), adjusted_close (a back-adjusted series — SPARSELY POPULATED, usually null, and retroactively restated on each corporate action so it is NOT PIT-immutable; prefer total_return_index), volume (shares traded), div_cash (ex-dividend cash per share on that date, 0 on non-dividend days), and split_factor (1.0 on non-split days). Never compute a return from raw close — a 4-for-1 split reads as a 75% crash. If total_return_index is null across the returned bars (a tier that has not re-exported since schema 2.29.0), the response note says so and you should compound close with div_cash / split_factor instead. For a company with more than one listing (dual-class, CVR), bars are the requested share class where the data supports it; `listing_resolution` and `multi_listing` on the response say which listing you actually received. Omit start_date for the trailing year before end_date. Omit end_date for the latest available close. Coverage follows your plan's tier slice: Pro and Institutional get the full daily bar series (full = all companies & all archived history, pro = all companies & last 15 years). On the free plans (sample, benchmark) this tool returns MONTH-END bars instead of daily ones: the close on the last trading day of each calendar month in range (not an average), COMPLETED months only (the month in progress appears once it ends), unadjusted, from up to 360 months (~30 years) of the same archive at coarser granularity — open/high/low/volume/adjusted_close are null on a monthly bar (nothing intraday to report), and close/total_return_index/div_cash/split_factor are populated. The response's `granularity` field says which series answered the call ('daily' or 'monthly'), and a monthly response's `note` spells out the upgrade path to daily bars. What every plan additionally has — the valuation multiples at each fiscal year end via get_financial_ratios (category 'valuation') and get_valuation_metrics, and 1/3/6/12-month momentum plus the 52-week high/low via get_earnings_signals. This archive is market data, NOT EDGAR, so it does NOT share the 1993 EDGAR floor that applies to fundamentals: the earliest bar differs per security and is 1994 or later. A request before a security's first bar returns zero bars on every tier, Institutional included, and is reported as DATA_COVERAGE rather than a plan limit.

Fetch the current HEAD of a report by id. `format=markdown` returns the rendered body, `format=json` returns the full structured payload (sections + citations + report-type-specific data), `format=preview` returns abstract-only. Authors see any of their own reports; non-authors only get `preview` of listed reports and need the report's required tier for full bodies. Sample-tier non-authors are downgraded to preview regardless of input. For an archived prior version use `get_report_version`, not this tool.

Author-only fetch of a specific archived version of one of your reports, by positive-integer `version`. Returns metadata + the full payload (sections, citations, structured, markdown) — enough to render a diff against the current HEAD in the workspace editor. Use after `list_report_versions` identifies the version number you want; for the current HEAD use `get_report` instead.

Fetch the Auditable Research File behind one of the caller's own agent runs — the complete evidence chain an examiner asks for: the originating prompt, every tool the agent called in order, every `fact_id` it cited, every human approval, and which models were used. Assembled from the immutable audit ledger written as the run executed; nothing here is reconstructed or inferred. Name the subject EITHER way, and pass exactly one: `report_id` (a report you wrote or found — from `create_report`, `list_my_reports` or `search_reports`) or `run_id` (from `list_agent_runs`). Naming a REPORT is the richer call: it resolves the run behind that report AND adds two sections a run's ledger cannot carry — `human_review` (each figure a HUMAN verified, corrected, rejected or sourced externally, with who and when) and `sources` (the SEC filing, form, period and filed date behind each cited fact_id). It also echoes the resolved `run_id`. A run-keyed call omits both, because a run may produce several reports and 'the report for this run' has no honest answer; empty or absent there means NOT RESOLVED, never 'no sources'. `format: "pdf"` returns the SAME assembled file as a branded compliance PDF instead of inline JSON — a 15-minute presigned download URL (`url` + `filename`) for the human-facing artifact (cover with the completeness verdict, evidence chain table, provenance with clickable sec.gov links). The PDF is rendered fresh on every call — never cached — because an in-flight run's ledger can gain entries, and a stale 'complete' verdict is exactly the lie this document exists to prevent. ⚠️ ALWAYS READ `completeness` FIRST AND REPORT IT. `completeness.complete` is computed from the ledger, and `completeness.gaps` names every hole found — an irreversible action taken with no named approver, a state-changing action that cited no fact_id, an unrecorded model, a failed step. If you present this run as evidence, present the gaps too; a chain with holes that is quoted as if whole is the one thing this artifact exists to prevent. ⚠️ `found: false` IS NOT A FINDING ABOUT THE WORK. It is returned (not as an error) for an unknown id, an id belonging to another customer, and a report with no run on record — deliberately indistinguishable, so no caller can probe which. It means we hold no audit trail under that id. It does NOT mean the report is unaudited, unverified, or that the id does not exist, and it must never be reported that way. Tier: sp500+ (sample rejected).

Get direct links to original SEC EDGAR filings for any US public company. Returns four per-filing deep links: `sec_url` (the EDGAR filing-index page listing every document), `viewer_url` (the cgi-bin Financial-Report viewer for the specific accession), `inline_viewer_url` (the SEC Inline-XBRL viewer opened on the rendered primary document — the strongest provenance link, `null` when the filing is not Inline-XBRL), and `document_url` (a direct link to the rendered primary document itself — opens the actual filing, never the index page, `null` only when primary_document is unknown). Prefer `inline_viewer_url ?? document_url ?? viewer_url ?? sec_url`. Supported form_types (enum): 10-K, 10-Q, 8-K, 20-F, 40-F, 10-K/A, 10-Q/A, 20-F/A, 40-F/A. Other forms (6-K, DEF 14A, Form 4, 13F) are NOT yet exposed by this tool — use `describe_schema` to confirm the parquet has them, then read raw via the SDK. 8-K item codes are filterable via `event_types` (e.g. ['2.02'] for earnings, ['1.01'] for material agreements, ['5.02'] for officer changes). PIT-safe — filings are filtered by accepted_at, never by report_date alone. Use this *instead of* `verify_fact_lineage` when you want a list of filings; use `verify_fact_lineage` when you want one specific fact-to-filing trace. Available on all plans.

Composite flow score on [-100, +100] aggregating insider transactions, 13F institutional Δ-shares vs the prior quarter, and SC 13D/13G blockholder changes over a lookback window. Each component normalised independently, then combined with configurable weights (default: institutional 0.4, blockholder 0.4, insider 0.2). Returns per-component attribution so an agent can see WHY the score is what it is — not just the headline number. NOTE: the institutional component is a QoQ share-change signal computed over the top-5 13F filers on a MATCHED current-vs-prior basis (a filer only counts when its prior-quarter book is observable), NOT the issuer's complete institutional book — treat the score as a directional signal, not an exact flow. `coverage.coverage_confidence` (0–1) reports how much of that basis had a real prior quarter; when it is 0 the institutional component is forced to 0 so a 13F ingestion gap can never surface as a false max-conviction buy. See the `coverage` block for holder coverage + staleness. The score is a unitless composite, not a dollar figure. Institutional tier only.