EdgeDepth Research MCP Server lets you search recorded Binance USDT-M and TradFi perpetual market microstructure, measure forward outcomes with denominators, and audit evidence reproducibly.
Explore the grammar and universe: list_features returns the closed feature/operator/window registry; list_instruments gives coverage, provenance, and instrument records.
Turn prose into proposals: interpret_prose converts plain-language questions into proposed research documents without executing them.
Run scans: run_scan executes exact research queries and returns counts, denominators, outcome summaries, reproducibility keys, and page rows; next_page pages through results.
Compare cohorts: run_cohort compares forward outcomes after matching conditions versus predicate-false baselines.
Measure base rates: base_rate counts how often a single condition is true over eligible symbol-minute buckets.
Inspect moments: snapshot_at reads all feature values at a recorded moment; commonality finds deterministic intersections across multiple moments.
Retrieve reports: get_report lists or fetches published reports by canonical hash.
Stay research-only and reproducible: no trading or account writes; results carry counts, denominators, reproducibility keys, ETags, and clear absence handling.
Provides market microstructure search and analytics over Binance USDT-M perpetual data, including feature-based scanning, outcome measurement, cohort comparison, and replay-linked evidence.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@EdgeDepth Research MCP Server Search for BTCUSDT with VPIN above 0.9 and show outcomes."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
@edgedepth/research-mcp is the official, research-only Model Context Protocol server for EdgeDepth, a market microstructure search engine over recorded Binance USDT-M crypto and TradFi perpetuals. Use it from ChatGPT, Claude, Cursor, Codex, or any MCP client to find every verified occurrence of a market condition, inspect forward outcomes across the complete matched set, read an unconditional same-scope reference, and open replay-linked evidence.
Every result includes counts with denominators and a reproducibility key. Same key, same bytes.
Website · Search the market · REST API documentation · MCP setup guide · Learning hub
Search recorded market microstructure: query a closed, versioned feature registry covering order flow, price action, volatility, funding, open interest, positioning, candle formations, and liquidations.
Keep the denominator: every count reports the eligible population and exclusions behind it. Missing data is absent, never silently changed to zero.
Measure outcomes without lookahead selection: forward returns, MFE, and MAE are computed over all occurrences. Outcome fields cannot be used as filters.
Compare matched and baseline populations: deterministic cohort results put the matched distribution beside every other eligible predicate-false bucket.
Audit and replay the evidence: results carry a reproducibility key, and representative occurrences include authenticated web handoffs to the exact recorded market moment.
Stay research-only: no tool trades, modifies alerts, publishes reports, or writes account data. A fresh scan, cohort, or stratified computation can consume research allowance units; the annotations state that side effect explicitly.
Related MCP server: polymarket-mcp
The package exposes one tool core through two transports:
Hosted MCP (recommended): connect to https://mcp.edgedepth.com/mcp over Streamable HTTP and authorize once in your browser. No API key to copy.
Local stdio: run npx -y @edgedepth/research-mcp with an EdgeDepth API key.
In Settings > Connectors > Add custom connector, enter:
https://mcp.edgedepth.com/mcpComplete the EdgeDepth browser authorization prompt.
~/.cursor/mcp.json){
"mcpServers": {
"edgedepth-research": {
"url": "https://mcp.edgedepth.com/mcp"
}
}
}~/.codex/config.toml)[mcp_servers.edgedepth]
url = "https://mcp.edgedepth.com/mcp"Then run:
codex mcp login edgedepthRemove any old bearer_token_env_var line before using browser OAuth.
Create a key on the EdgeDepth Developer page, then add:
{
"mcpServers": {
"edgedepth-research": {
"command": "npx",
"args": ["-y", "@edgedepth/research-mcp"],
"env": {
"EDGEDEPTH_API_KEY": "edk_live_YOUR_KEY"
}
}
}
}Local stdio requires Node.js 20 or newer. Use the research:read key scope for recorded-data tools and add research:interpret only when you need the free interpret_prose proposal step.
Scan-family results are large: a universe scan's canonical bytes run to
hundreds of kilobytes, most of it page rows carrying every recorded feature,
the zero and long-tail entries of counts_by_symbol, and empty threshold
rungs. That overflows a client's tool-result budget before it answers anything.
run_scan, next_page and run_cohort therefore return a stated
projection by default. It only ever REMOVES, and every removal is listed in a
trailing note with the exact way to get the bytes back:
occurrence rows are trimmed to rows (default 3) and each kept row keeps the
setup fields its own evidence block names - full_rows: true restores the
whole vector;
the per-occurrence outcomes map keeps the entries for the rows that remain;
counts_by_symbol keeps the top entries by match count, and says how many
instruments and matches were omitted;
the outcome ladders are replaced by a paired answer block: for each metric,
present, absent and the selected rungs' integer counts pass through
verbatim, with rate, the unconditional baseline_rate over the same
symbols and window, and their ratio as lift stated beside them. The
selection is fixed in advance (gte 0.01, gte 0.02, lte -0.01,
lte -0.02), drops rungs that separate nothing, and adds the single rung
carrying the largest lift among those holding at least 30 occurrences,
marked kept_for. full_outcomes: true returns every rung and the per-rung
histogram, on the matched set and the reference separately.
Counts, denominators, absent tallies, predicate_coverage, representatives,
the page cursor and the reproducibility key are never touched, and the request
document is never rewritten, so the canonical query hash and the credit charged
are exactly what you asked for. full_counts: true returns the engine's
verbatim canonical bytes with no projection at all. ETags are
projection-scoped: an ETag held for one projection can never revalidate as a
different one.
list_features takes the same treatment on request: search, feature_ids
and compact return one feature family instead of the whole grammar, with the
closed parts (operators, windows, sequence rules, limits, error codes) intact.
The server publishes worked prompts, which compatible clients surface as
pickable commands: test_a_claim, liquidation_cascade_bounce,
investigate_symbol, what_preceded_moves_like_this, does_it_confirm and how_common_is_it (the free
prevalence path). Each one encodes the same answer contract: ground the
grammar, propose the exact definition, wait for confirmation, then report with
denominators, the reference, the reproducibility key and a replay handoff.
The grammar registry is also served as a resource, edgedepth://research/grammar,
so a client can attach it once instead of calling list_features every session.
For setup-first questions, interpret prose in the host and call prepare_study with structured scope, predicates and outcome. It reuses the web validator and measure contract, validates current instrument membership and returns an unrun canonical definition plus a fresh allowance estimate. No external LLM is used. Preserve user_stated, semantic_translation (top 10% means rank >= 0.9) and model_assumed separately; only the latter denotes an invented proposal. Use interpret_prose unchanged as the raw-prose fallback. Use compact list_features for uncommon fields or validation repair, not every question.
Call list_instruments only when you need to check the manifest-derived universe, coverage, and provenance. Its result carries the human market page in the same way, https://edgedepth.com/research/symbols/<symbol>, for a market still being recorded; a delisted market in the universe has no page, so offer that link rather than promising it.
Show one short proposal: condition, exact markets and dates/time zone, outcome definition and horizon, and metering. Interpretation is free; fresh computations can consume allowance. Label every unprovided value as a proposed assumption using chip provenance. Resolve unsupported fragments and ask only questions that materially change the study. Keep exact JSON and diagnostics inspectable in tool details, available on request.
Wait for explicit human approval, then pass the same document to run_scan. Changes require a new proposal and confirmation. The exact-document API does not store a proposal ID or a human approval receipt; client consent is required, and a model-supplied flag is not proof. On the supporting web release (b68c744 or later), returned rq workbench links load editable proposals and wait for Run; navigation never authorizes computation.
Answer the question first, preserving zero-match and inconclusive findings. Give matched/eligible counts, coverage exclusions, present/absent outcomes, both directions at the agreed horizon, and overlap/selection limitations. Read rates from outcomes_summary, which covers all occurrences. Page rows are examples, never the denominator. Each rung already carries its matched count and rate, the unconditional rate, and their ratio as lift: quote those, and quote the count beside the rate. No lift means no reference was available or the unconditional rate was zero; neither licenses estimating one.
Read the appended unconditional same-scope reference when available. It is not matched, comparable, or a causal control.
Return the full reproducibility key with the answer and one relevant next action: a returned replay, a changed assumption, or an existing report. Saving and alerts remain web actions. Each handoff states how far back it sits; replay reach is a per-account entitlement, so an old moment can be refused at the web surface even though the occurrence is real. Use next_page only with a cursor returned by the API.
Example instruction for an MCP client:
Did elevated VPIN and one-sided buying tend to precede a rise? Propose a precise
study before running anything. Label any suggested thresholds, markets, dates
and outcome definition so I can approve or change them.The user does not need tool names, feature IDs or JSON. The client translates the confirmed proposal into the existing exact-document call.
For an outcome-first question, use outcome_first after agreeing the target and
scope. Preserve touched-within (reached) versus close-at-end (finished),
direction, size and horizon. Do not pass the outcome to the setup interpreter or
substitute the worked example. The target grammar is available at
edgedepth://research/outcome-first.
Report the population and both counted shares for each displayed reading. Help
the person choose one reading, retrieve its setup_first_rerun with full_rows: true on the unchanged request, and confirm that exact setup before run_scan.
Pass the original target as run_scan.measure outside the unchanged document:
kind: "touch" for reached, "close" for finished, plus the agreed direction,
fractional magnitude and horizon. The returned workbench link keeps that display
choice and remains an unrun draft. This does not alter the scan/cache key. The local selected-outcome addition below preserves the exact reading separately from closing-return exploration.
Read the original outcome target from the complete matched-set summary; request
full_outcomes if the projection omitted its rung. An unavailable rung is stated,
never replaced by the default horizon. The two reads have different denominators.
A same-period rerun remains exploratory; freeze the condition and use a separate
period before claiming validation.
A named moment can be inspected with snapshot_at; commonality compares multiple
supplied moments. The screenshot path below adds bounded explicit close-range investigation and the existing
detector geometry. Automatic move selection is not exposed through MCP. Historical marker browsing and general volume-tier resolution are not MCP
capabilities yet. The local resolve_scope addition below supplies explicit sector resolution after its web release. list_instruments supplies coverage and instrument provenance,
not sector membership. Use resolve_scope for recorded sector membership when available; otherwise use an exact supplied roster;
never invent group members or a numeric price. Replay handoffs open the web surface
and remain subject to the person's coverage and entitlement.
Tool | What it does |
| Returns the closed grammar registry: feature ids, types, ranges, operators, windows, sequence rules, limits, and error codes. |
| Returns the research universe and coverage. The default is a compact summary; use |
| Free deterministic structured preparation, provenance and allowance estimate. Requires the web |
| Turns prose into a proposed query document. It does not execute the query. Optional |
| Executes a |
| Continues a prior scan with its opaque cursor. Never construct cursors manually. |
| Resolves host-extracted screenshot coordinates against recorded candle closes and coverage, retaining uncertainty and deduplicating event views. Free. |
| Reads the existing lead-up and optional recorded detector geometry for a grounded event, and optionally prepares exact unrun setup documents. Free read; historical entitlement applies. |
| Reads registry feature values, window aggregates, and fired rules as of a recorded moment. |
| Counts matches and eligible buckets for one clause over a window. |
| Finds the deterministic intersection across multiple moments with selection-bias caveats included. |
| Retrieves a published report by its 8-character canonical hash. |
| Compares what followed every match with what followed every other eligible predicate-false bucket. |
| Partitions one matched population at its existing anchors into split-true, split-false, and split-absent outcome summaries. |
| Starts from the MOVE instead of the setup: names an outcome (size, direction, horizon) and reports what the record was doing at five fixed offsets before every realised move like it. Each row carries two counted shares, the share before these moves and the share across every eligible minute in the same scope, plus the setup-first rerun that re-tests it the other way round. A descriptive read, never a rule search: a row is not a rule, a candidate or a finding, and the row order is display order. A scope with too few realised moves is refused with its counts and four adjustments, and a refusal spends nothing. Projected by default ( |
No tool can trade, change market state, publish, or modify account data. run_scan, run_cohort, run_stratified and outcome_first are annotated as metered computations because a fresh call can irreversibly consume an allowance unit. The other recorded-data tools are closed-world reads. interpret_prose is a free read that uses the configured external language interpreter.
Validation failures pass through as 422 {"errors":[{"code":"...","message":"..."}]}.
Transport failures use the {"error","code"} envelope.
Contract codes are machine-actionable. For errors such as UNSUPPORTED_FEATURE or OUTCOME_IN_PREDICATE, call list_features, repair the document, and retry.
Deterministic tools are exact-document, UTC-only tools. interpret_prose may use a time zone to plan dates, but run_scan, run_cohort, and base_rate never reinterpret calendar language.
Reruns and ETag 304 Not Modified revalidations are free. list_instruments ETags are scoped to the requested summary, symbol projection, or full representation.
Interpretation is free and never debits the scan allowance. An unavailable scan allowance returns neutral 402 RESEARCH_ALLOWANCE_EXHAUSTED metadata without a checkout link.
The MCP server is a thin, deterministic interface to the public EdgeDepth Research API:
The default REST base used by the stdio package is https://app.edgedepth.com/api/v1/research.
Variable | Default | Purpose |
| None | Required for stdio tool calls. |
|
| Optional REST API base override. |
Variable | Default | Purpose |
|
| OAuth access-token exchange endpoint. |
| None | Required internal assertion secret; must match the web app. |
|
| HTTP listen port. |
|
| HTTP listen host. |
The hosted server uses browser OAuth. It validates opaque access tokens, exchanges them for separate short-lived internal assertions, and never passes the OAuth access token to the REST API. The MCP server is stateless and stores no user credentials.
Compatible clients rotate refresh tokens silently while the connection remains active. Review or revoke access at EdgeDepth Connected Apps.
API keys remain available for scripts, local stdio, and MCP clients without browser OAuth. Treat an edk_live_... key as a secret and never commit it to source control.
npm install
npm run build
npm test
npm run typecheckTypeScript builds to dist/. Example nginx locations, systemd hardening, and operator environment values live under deploy/. Production deployment and npm publishing remain operator actions.
edgedepth-terminal (AGPL): the open-source C++/WASM orderflow terminal. Replay-linked evidence from research results opens the exact recorded market moment in it, and it self-hosts with one docker compose command.
edgedepth-gateway (MIT): a Go bridge from Binance's public streams to the terminal's wire format, for running the terminal on live data without an account.
MIT
Supported MCP Apps hosts can display a comparison and recorded-distribution card
from run_scan. The card receives only complete-result forward-return summaries,
coverage, exact query/key and metering in tool-result _meta. This data is hidden
from the model in ChatGPT; the existing text projection is unchanged. No raw page
observations are used to make distributions, no fitted curves are invented, and
no additional requests or allowance consumption occur when changing chart views.
Reference distributions are compared only when their bin edges align. Empty bins,
open tails, missing outcomes and zero/one-observation states remain visible.
Horizon and move-size controls are display choices over already-computed outcomes,
not changes to the approved query. The card defaults to the labelled 1h / 1% view.
Exact study/evidence details expand inside the card; text-only hosts keep the
existing response. The HTML resource has no network dependencies or mutations.
This is a developer-connector update, not an automatic official V1 rescan.
Attach charts to a vision-capable host and use investigate_screenshots. The host
reads the images; the server receives screenshot_observation.v1 facts through
ground_screenshots. The contract is edgedepth://research/screenshots. No second
image model or automatic attachment access is used.
Grounding is free for every authenticated tier. It checks explicit minute-close boundaries against recorded Binance futures candles and manifest bounds, retains visible/inferred/user/missing provenance, and deduplicates exact event views. Unclear dates, zones, inferred boundaries, conflicting coordinates and overlapping examples need one clarification. No default date, venue substitution or nearby move search occurs. Wick tick timing and unsupported drawings are not matched.
investigate_move rechecks the event and reuses the web's five lead-up offsets,
recorded detector evidence and setup-combination builder. It consumes no allowance;
historical snapshots retain their existing entitlement. Optional exact study scope
and target return unrun setup_first_rerun documents, an allowance estimate and an
editable workbench link. The default response omits duplicate source snapshots and detector candle bars,
with full_sources: true restoring the complete bytes. All reading values, exact
setup documents, source metadata, gaps and parity stay inspectable; a free re-read
may see a newer revision. Population counts and forward rates still require the existing
outcome_first or run_scan, after a concrete proposal and explicit human approval.
The exact target stays separate from the setup predicate. Selected winning examples
and same-period reruns remain exploratory; use a separate period before validation.
Replay coverage and entitlement remain independent of research history.
Deploy the web's /api/v1/research/investigate/ground, /investigate and /evidence
routes before releasing these MCP tools. The workbench on web b68c744 loads rq
as an editable proposal and waits for Run. Do not use the new proposal links with older releases that execute on arrival.
Historical-marker and named-collection MCP parity remain separate work. The returned
estimate is for each prepared setup, not a general quote endpoint.
Local deterministic tests exercise extracted observations and authenticated handlers
with fixtures. They are not image-model or vision-host acceptance. Follow the
test/screenshot-host-acceptance.md cases in an actual vision-capable host before
claiming that upload-to-investigation works end to end.
Adds explicit screenshot grounding and move investigation, with compact source
projection by default and full_sources: true when the complete evidence is needed.
The host reads the images; the MCP validates structured observations and exact
recorded coordinates. Ambiguity requests clarification rather than inventing a move.
Saved scans, cohorts, comparisons and outcome-first studies remain readable when allowance is exhausted. The web uses dedicated engine cache-read routes; a missing result cannot start a new computation. A cache is revision-bound and may be evicted, so this is not a promise of permanent result storage. General replay access depends on the recorded date, market and plan; research links do not confer an event grant.
prepare_study accepts scope (symbols, offset-qualified from/to, provenance),
setup (field/operator/value/provenance) and outcome (reached/finished, direction,
fractional magnitude, horizon, provenance). Source metadata stays separate from
the hashed query. Screenshot anchors must be visible or user supplied; uncertain
times need clarification. Retrieve EdgeDepth readings with snapshot_at first.
Qualitative rules remain model_assumed until the person approves the proposal.
The server validates host claims, but cannot verify what the host actually saw.
get_report defaults to a stated, fixed 1h overview with source counts and stored
integrity status. It does not claim to revalidate the pin. full:true restores
complete stored bytes, including all outcomes and definitions. This selection
is not a saved requested measurement. Public report reads remain free.
Deploy web before MCP. No production latency or vision-host acceptance is implied by local deterministic tests.
Deploy web /api/v1/research/scope before this MCP build. resolve_scope uses
recorded sector tags and the same resolver as the web move-first door, filtered
to confirmed Binance crypto linear perpetuals. It returns the exact roster and
per-market history; missing/ambiguous/thin/oversized populations stay blocked.
There is no automatic widening. Membership is current recorded classification,
not point-in-time membership, and history does not prove feature completeness.
run_scan.measure now adds selected_outcome.v1 alongside canonical bytes,
including the exact selected full-population count, opposite direction and
unconditional reference. Zero counts remain visible, zero denominators have no
rate, and unavailable metrics or rungs are never substituted. The inline view
leads with that same reading; its secondary chart remains explicitly closing-
return exploration. Existing reports keep their fixed, stated overview.
Similarity is exploratory proximity on stated dimensions. Monitoring requires exact satisfaction of a versioned supported predicate, not identical historical numbers. A discovered threshold must be labelled proposed, frozen before a separate-period evaluation, and any tuning disclosed. No similarity-to-alert conversion, trading-rule evaluator or automated forward-test readiness verdict is added. Saving and monitoring use the private web handoff and explicit confirmation. An alert reports condition satisfaction, not a repeat prediction.
Use run_trade_test only after a separate explicit proposal and human approval. It wraps the exact record population in trade_query.v1 with all trade_rules.v1 parameters and string-valued source_measurement provenance. Default proposals: 1% stop, no fixed target, 2% close-ratcheted trail, 240 minute bars, 6 basis points fee and 10 basis points slippage per side, skipping same-market signals until exit. Choose long/short explicitly. These are editable assumptions, not optimal parameters. Limits are 31 days, 100 explicit markets and 5,000 signals.
Entry is the next minute open. Gap stops fill at the worse open, and stop wins if stop and target occur in one bar. Trails update from completed closes and apply from the next bar. Missing opens/price bars are unavailable; no prior-close substitution. Bucket ends are interval labels, not exact fill timestamps.
Read wins, losses, average win/loss and expectancy from the complete trade summary, never from MFE or page rows. Returns include fees/slippage but omit funding and other execution costs; they are not fully net or portfolio returns. Keep the original question, selected_measure JSON, measurement version, query hash, dataset revision and source investigation in source_measurement. Web saves and downloads retain the result. Alerts remain separate setup recurrences.
Backend and web releases must precede the MCP. Old periods without an open column return TRADE_OPENS_UNAVAILABLE without computation or debit. New schema rows can still be missing and are counted individually. No npm/registry publication is authorized by the hosted release.
Trade results default to the complete summary and first ten chronological journal examples. full_trades:true restores all canonical bytes. Projection-specific ETags prevent revalidation across these display modes; neither mode changes the rules, complete-result counts, reproducibility key or computation charge.
get_investigation_bundle reads an existing SHA256 bundle ID through the same
API as the web. Compact output retains exact event/as-of bounds, source receipts,
metrics, deterministic observations, contradictory evidence and missing analyses;
full: true restores pinned input observations. No model, scan, allowance debit
or publication occurs. Missing comparable populations stay unavailable and use
the existing exact-study approval flow when requested. Backend and web readers
and explicitly reviewed artifacts must be provisioned before this tool can read
a bundle; this change does not enable a publishing job.
The first cross-venue replication slice adds exchange=hl to API v1 universe
reads and exchange: "hl" to MCP list_instruments. Omission remains Binance.
Exact record documents select HL with ["identity.exchange", "eq", "hl"] and
recorded lowercase IDs such as btc. Only one venue is permitted per document;
run paired definitions separately over verified overlapping feature coverage.
Binance canonical hashes, default scope and result bytes remain unchanged.
Daily/consolidated reads, query/baseline/cohort/prevalence/stratified/trade wrappers, page setup hydration and revision checks follow the selected venue. Missing features stay absent. HL metadata not established by manifests stays unknown. HL live monitoring and replay/workbench handoffs are unavailable in this slice. Outcome-first, snapshot, prose preparation, named scopes and UI venue selection remain separate gates; do not infer HL support there from record validation.
Delivery order is backend, web API/validator, then MCP. No source extraction,
dataset promotion, capture change or production release occurred. Local BTC
September 12 proof and continuation owner are in the task hub's canonical
tasks/research-cross-venue-replication.md and outputs/cross-venue-20260915/.
Measure how often a SINGLE stated condition is true over all eligible symbol-minute buckets in a window. base_rate_result.v1 reports predicate_true_buckets, predicate_false_buckets, eligible_buckets, absent_or_ineligible_buckets and true prevalence globally and per symbol. This is not a count of false-to-true occurrence episodes and computes no forward outcomes. Missing values are excluded from eligible, never coerced to false or zero. Deterministic and free, including reruns. field, operator and value must be grammar-valid (see list_features); expect the 422 contract code verbatim if not. The assembled one-clause document is echoed back so you can show the user exactly what ran.
| Name | Required | Description | Default |
|---|---|---|---|
| to | Yes | Window end, RFC3339. | |
| from | Yes | Window start, RFC3339. | |
| field | Yes | A feature.* or window.* id from list_features (e.g. feature.vpin). | |
| value | Yes | A number for numeric fields (send a JSON number, not a quoted string), a label for enum fields, or an array for between/in. String-encoded numbers and arrays are repaired deterministically. | |
| symbol | No | Optional scope: one lowercase perp or a JSON array of them. Omit for the whole universe. A string-encoded array is repaired deterministically. | |
| operator | Yes | gte, lte, between, eq or in - matching the field dtype. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description significantly expands on the annotations (readOnlyHint=true, openWorldHint=true) by disclosing behavior around missing values ('never coerced to false or zero'), determinism ('Deterministic and free, including reruns'), error code expectations ('expect the 422 contract code verbatim'), and output echo. It also describes the output structure (base_rate_result.v1 fields), which is especially valuable given no output schema is present.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured paragraph of about 7 sentences, each delivering distinct value: purpose, output fields, exclusions, missing-data handling, guarantees, error behavior, and the echo. It is front-loaded with the core purpose and avoids redundancy with the schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description fully compensates by listing the exact result fields (predicate_true_buckets, predicate_false_buckets, eligible_buckets, absent_or_ineligible_buckets, true prevalence) and global/per-symbol breakdown. It covers edge cases (missing values, grammar errors, determinism) and the echo behavior, making the tool's behavior completely understandable without needing to guess.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds meaningful parameter context beyond the schema by stating that 'field, operator and value must be grammar-valid (see list_features)' and warning about the 422 error code for invalid grammar. It also clarifies the meaning of 'eligible' buckets. These additions go beyond the schema's property descriptions, justifying a 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool measures how often a single condition is true over eligible symbol-minute buckets, with a specific verb ('measure') and resource scope. It distinguishes itself from sibling tools by noting it is not a count of false-to-true episodes and computes no forward outcomes, differentiating it from tools like run_scan that may analyze outcome episodes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context for use: 'SINGLE stated condition' and 'eligible symbol-minute buckets,' and explicitly says it is not for episode counts or forward outcomes. It does not name an alternative sibling directly, but the exclusions are strong enough to guide when not to use it, and it references list_features for grammar validation. However, it lacks an explicit 'use X instead' statement, so it doesn't quite reach a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Given N (symbol, time) moments, return the DETERMINISTIC intersection: per registry field a verdict of agree, partial, disagree, quiet or absent, plus the survivorship and multiple-comparisons honesty framing IN the output. Never similarity search. A shared feature is a description of the chosen moments, not a prediction: to test any AGREE chip, follow up with base_rate over the same window.
| Name | Required | Description | Default |
|---|---|---|---|
| moments | Yes | At least 2 moments: { symbol: lowercase perp, at: RFC3339 }. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark readOnly and openWorld; the description adds specifics about deterministic output, verdict values, and survivorship/multiple-comparisons framing. It does not contradict annotations and provides extra behavioral detail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two compact sentences that convey purpose, output format, exclusion, and follow-up guidance without fluff. Each clause adds value and the description is well front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description explains the return value composition (per-field verdicts and framing) and disambiguates from prediction tools. There is slight ambiguity around 'framing' but overall it is complete for a read-only tool with no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema already fully describes the moments parameter (array of {symbol, at}, min 2, lowercase perp, RFC3339). The description adds no additional parameter-level meaning beyond the schema, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'return' and defines the resource as a deterministic intersection with explicit verdict types (agree, partial, disagree, quiet, absent). It also clearly distinguishes from similarity search, differentiating it from sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states 'Never similarity search' as a when-not, and provides actionable follow-up advice to test AGREE verdicts with base_rate. This gives clear context for when to use this tool versus alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Omit hash8 to list published archive and record reports with count, revision and explicit integrity status. Provide an 8-hex canonical hash to fetch one report: structurally generated title, author, the definition that ran (re-submittable to run_scan) and the result pinned at publish time. Invalid or withdrawn reports carry correction and successor metadata and must not be presented as healthy.
| Name | Required | Description | Default |
|---|---|---|---|
| hash8 | No | Optional 8 lowercase hex canonical id. Omit to list public reports. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes beyond the readOnlyHint and openWorldHint annotations by disclosing that invalid or withdrawn reports carry correction and successor metadata and must not be presented as healthy. It also clarifies the return content (count, revision, integrity status) and the nature of the result pinned at publish time. This provides rich behavioral context without contradicting annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the conditional behavior (omit/provide) and packed with essential information. No filler or repetition. It is concise despite covering both modes and edge cases.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description fully covers the tool's behavior given the lack of an output schema: it describes what is returned in list mode (count, revision, integrity status) and fetch mode (title, author, definition, result), and warns about invalid/withdrawn reports. With only one optional parameter and good annotations, this is complete for an AI agent to select and use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already has 100% coverage of the single parameter, but the description adds significant meaning: it explains that omitting hash8 lists reports, while providing it fetches one and details the returned fields (title, author, definition, result). This goes beyond the schema's 'Omit to list public reports' by fully explaining the dual behavior.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: it lists published archive and record reports when hash8 is omitted, and fetches a single report by an 8-hex canonical hash. It uses specific verbs (list, fetch) and identifies the resource (reports). The description also distinguishes from siblings like list_features and list_instruments by scoping to reports with integrity status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides mode-specific instructions: omit hash8 to list reports, provide hash8 to fetch one. This effectively guides when to use each mode. However, it does not explicitly name alternatives or state when not to use the tool, though the sibling tool run_scan is indirectly referenced via 're-submittable to run_scan'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Turn a plain-language market question into a PROPOSED research_query.v2 document. The result is a proposal, not a result: it is labeled proposal:true and is never executed here. Show the document (plus any unsupported[] stand-ins and clarify notices) to the user, then call run_scan with the document to execute. That second call is the confirm gate. Requires the research:interpret scope and is metered separately (each call spends provider money).
| Name | Required | Description | Default |
|---|---|---|---|
| language | Yes | The market question in plain language, e.g. "vpin above 0.7 then a liquidation surge within 30m on majors last week". | |
| time_zone | No | Optional IANA identity used only to interpret local calendar language, for example Asia/Bangkok. Omit to use the public API default, UTC. Explicit prose such as "June 7 UTC" overrides this default. Abbreviations such as CST are rejected. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses several behavioral traits beyond the annotations: the result is labeled proposal:true, it is never executed here, output includes unsupported[] stand-ins and clarify notices, it requires the research:interpret scope, and each call spends provider money. This goes well beyond the readOnly and openWorld hints, and no contradiction with annotations exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is four sentences, each serving a distinct purpose: purpose, proposal nature, workflow with run_scan, and auth/cost. It is front-loaded with the core function and contains no filler or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given there is no output schema, the description compensates by explaining the output (proposal:true, unsupported[] stand-ins, clarify notices), the workflow (show to user, then run_scan), and important operational details (scope and cost). It covers all essential aspects for an agent to correctly select and invoke this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with both language and time_zone already fully described in the input schema. The description adds general context (e.g., 'plain-language market question') but no parameter-specific details or new meaning beyond the schema, so the baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Turn a plain-language market question into a PROPOSED research_query.v2 document.' It emphasizes that the result is a proposal, never executed, which distinguishes it from the sibling run_scan tool that executes scans. The verb 'Turn' and specific output resource make the purpose explicit and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear usage context: it says to show the proposal to the user and then call run_scan to execute, framing this tool as the first step in a two-step workflow. It also notes the required scope and metering. However, it does not explicitly state when not to use the tool or provide alternative scenarios beyond run_scan, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the closed registry for the pinned feature_version: every feature id with its dtype and range, the operators, window aggregates and durations, sequence rules, limits, sort fields, and the machine-readable validation and transport error-code lists. Call this FIRST: a document that only uses ids from here cannot invent field names. The registry is ETag-revalidated on every read, so additive feature ids become visible to long-running agents without inventing or hard-coding fields.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations declare readOnlyHint and openWorldHint, but the description adds the crucial ETag-revalidation behavior, explaining that additive feature ids become visible to long-running agents. This goes beyond the annotations and provides useful operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, each with a distinct purpose: enumerating contents, instructing to call first, and explaining caching behavior. No filler words; all sentences contribute essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite lacking an output schema, the description thoroughly enumerates what the response contains, including feature ids, dtypes, ranges, operators, window aggregates, sequence rules, limits, sort fields, and error-code lists. It also justifies the 'call first' guidance and caching, making it fully self-contained for a read-only registry tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline is 4. The description does not need to elaborate on parameters; instead, it focuses on the richness of the response. It conceptually mentions 'pinned feature_version' but does not treat it as an input parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns the closed registry for the pinned feature_version, enumerating the specific contents (feature ids, dtypes, ranges, operators, etc.). This distinguishes it from sibling tools like list_instruments, which likely return a different registry.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs 'Call this FIRST' and explains why: using only ids from this registry prevents inventing field names. This provides clear guidance on when to use it, though it doesn't name alternative tools explicitly, the context implies it is the foundational reference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the authoritative feature-store universe derived from complete manifests. DEFAULT: a compact deterministic summary (coverage window, dataset revision, instrument counts by availability status) - the full body is ~360 KB and overflows agent contexts. Pass symbols: ["btcusdt", ...] for the complete canonical records of specific instruments (per-instrument coverage, present/excluded partition counts, provenance, replay entitlement). Pass full: true for the verbatim canonical bytes of the whole universe. Excluded symbol-days remain visible as universe membership. NVDAUSDT and QQQUSDT are Binance USDT-M perpetuals referencing TradFi assets, not direct Nasdaq data. This read is deterministic and free in every mode.
| Name | Required | Description | Default |
|---|---|---|---|
| full | No | True for the verbatim ~360 KB canonical universe bytes. | |
| symbols | No | Return only the full canonical records of these instruments (lowercase perps, e.g. ["btcusdt","ethusdt"]). A string-encoded array is repaired deterministically. | |
| if_none_match | No | Optional ETag to revalidate an unchanged result for free. ETags are projection-scoped: pass back the ETag this tool returned for the SAME mode (full/summary/symbols). An ETag from a different mode never matches. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond readOnlyHint and openWorldHint, it reveals determinism, cost-free access, authoritative derivation, excluded symbol-day visibility, and the Binance perpetual mapping for NVDAUSDT/QQQUSDT. This is far richer than annotations alone, with no contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Dense but efficient; every sentence contributes value. It is somewhat long due to explaining three modes and an overflow warning, but that complexity justifies the length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description fully explains return modes, content of each mode, size constraints, determinism, cost, and edge cases. It provides all necessary context for an agent to invoke and interpret results correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, yet the description adds substantial meaning: default output fields, per-symbol record contents, lowercase convention, string-array repair, and ETag projection scoping. This goes well beyond the schema's own property descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns the authoritative feature-store universe from complete manifests, with distinct modes for summary, specific symbols, and full bytes. This specific verb+resource clearly distinguishes it from siblings like list_features.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit mode selection guidance: default compact summary avoids context overflow, symbols for specific canonical records, full for verbatim bytes. However, it does not explicitly name alternative tools for when not to use this one, so a small gap remains.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Continue a prior run_scan by re-sending the SAME document with the opaque cursor from the previous response. Never construct cursors. If X-Dataset-Revision changed since page 1, the data under THIS document changed (e.g. the nightly append) and the result set with it: restart from page 1. The revision is scoped to the document's symbols and window - never compare revisions across different documents. Every page has its own ETag and remains free, including a continuation cache miss. Complete-result counts and summaries remain independent of the page rows. Same counts_by_symbol projection as run_scan; full_counts: true for verbatim bytes.
| Name | Required | Description | Default |
|---|---|---|---|
| cursor | Yes | The opaque page.cursor from the previous response. Never construct or edit it. | |
| document | Yes | The EXACT document from the prior run_scan. | |
| full_counts | No | True returns the engine's verbatim canonical bytes, including every zero-count instrument in counts_by_symbol. Default omits zero-count entries. | |
| if_none_match | No | Optional ETag to revalidate this page. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnly and openWorld hints, but the description adds substantial behavioral context: cursor handling, revision scoping, ETag details, pricing/free nature, and independence of counts and summaries. This goes well beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but each sentence contributes important operational detail. It is front-loaded with the core action and then presents necessary edge-case handling. Length is appropriate given the complexity, though it could be slightly more concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description compensates by explaining the counts_by_symbol projection, full_counts behavior, and independence of page rows. It covers critical complexities like revision changes and ETags, making the tool sufficiently understandable for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with detailed parameter descriptions. The tool description mostly reinforces these (e.g., 'SAME document', 'Never construct cursors') without adding new parameter-level meaning beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: to continue a prior run_scan by re-sending the same document with the opaque cursor. It is specific and distinguishes itself from the sibling run_scan tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly describes when to use this tool (after a prior run_scan) and provides concrete guidance, such as restarting from page 1 if X-Dataset-Revision changed, and never constructing cursors.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Execute a research_query.v2 document as a predicate-complement comparison and return canonical cohort_result.v2 bytes: what followed the condition (the treatment side, byte-identical to the run_scan outcomes_summary for the same document) vs what followed every OTHER eligible bucket where the full predicate was FALSE (the baseline), each as the same 30m/1h/4h/24h return + MFE/MAE summary over ALL occurrences. WHERE-ONLY: a sequence document is refused with 422 COHORT_SEQUENCE_UNSUPPORTED (run it as an ordinary run_scan instead). The bytes carry NO ratios, lift, averages or significance - you compare the two distributions yourself. This is not covariate matching: treatment/baseline identities, different observation units, dedupe difference, and denominator arithmetic ship in the result with three mandatory caveats. Both sides honour the completeness rule: an occurrence closer to the end of recorded data than a horizon has that horizon ABSENT - quote present, not total, as the denominator. CONTRACT (relay to the user): Echo the exact document and the reproducibility key to the user with the result. Rates come from outcomes_summary over all occurrences; page rows are examples, never the denominator. Outcome fields cannot be filtered; expect OUTCOME_IN_PREDICATE if tried. A rerun of the same document is served from cache (X-Research-Cache: hit) in its own cohort namespace; reruns and 304 revalidations are free.
| Name | Required | Description | Default |
|---|---|---|---|
| document | Yes | A complete research_query.v2 document (target record_occurrences, WHERE-ONLY - no sequence). Call list_features for the grammar; do not invent field names. | |
| full_counts | No | True returns the engine's verbatim canonical bytes, including any zero-count instrument in counts_by_symbol. Default omits zero-count entries when present. | |
| if_none_match | No | An ETag from a previous cohort run to revalidate: identical data answers 304 and spends nothing. Pass it back verbatim (it may be weak, W/"..."). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Even though annotations declare readOnlyHint=true, the description adds substantial behavioral detail: exact byte output, absence of ratios/lift/averages, completeness rule, cache behavior with X-Research-Cache header, and mandatory caveats in the result. It also discloses error conditions like OUTCOME_IN_PREDICATE and the contract to echo document/key. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is long but every sentence adds critical operational information, from return format to error handling to caching. It is front-loaded with the core purpose, then systematically adds caveats. The density is justified by the tool's complexity, and no sentence feels redundant.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description compensates by detailing the cohort_result.v2 bytes, time windows, MFE/MAE summary, and what is absent. It also covers error scenarios, contract requirements, and cache semantics, making the tool fully understandable. The description is complete given the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description enriches the document parameter by requiring WHERE-ONLY and explaining predicate-complement semantics, and clarifies if_none_match by describing ETag revalidation and 304 responses. Full_counts is not further elaborated in the description, but the schema description is already sufficient, so the added value is above baseline but not maximal.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it executes a research_query.v2 document as a predicate-complement comparison, returning canonical cohort_result.v2 bytes with treatment vs baseline side-by-side. It explicitly names the alternative run_scan for sequence documents, distinguishing it from that sibling. The verb-resource-object structure is explicit and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs to use run_scan for sequence documents (WHERE-ONLY refusal with 422), provides a when-not for covariate matching, and warns against outcome field filtering. It also describes cache revalidation semantics for if_none_match, giving clear decision boundaries for when to invoke this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Execute a research_query.v2 document over the deterministic engine and return counts, denominators, outcomes_summary, the reproducibility key and page-1 rows as the engine's canonical bytes. outcomes_summary carries forward outcomes over FOUR horizons per occurrence: 30m return, 1h MFE/MAE, and 4h and 24h return + MFE/MAE (record_result.v3), with a closed threshold ladder to +/-20 pct - "how often did this setup reach +5% within 24h, with how much drawdown" is answered by the summary over ALL occurrences. Completeness caveat: an occurrence closer to the end of recorded data than a horizon has that horizon ABSENT (counted in the absent tally, never a truncated or implied-zero outcome) - quote present, not total_matching, as the denominator for any horizon rate. Document-only input: stated chips are the only input the scan path accepts (use interpret_prose first if you have prose, then re-submit its document). CONTRACT (relay to the user): Echo the exact document and the reproducibility key to the user with the result. Rates come from outcomes_summary over all occurrences; page rows are examples, never the denominator. Outcome fields cannot be filtered; expect OUTCOME_IN_PREDICATE if tried. sequence.within accepts 15m/30m/1h/4h/12h/24h and the matching ISO aliases; both normalize to canonical ISO before hashing. identity.symbol must be an exact lowercase Binance USDT-M perpetual symbol: case, whitespace and separators are rejected. You may rerun freely: a rerun of the same document is served from cache (X-Research-Cache: hit), and reruns and 304 revalidations are free. SIZE: page rows carry full 33-feature setup vectors (~2 KB each); page.limit 50 returns ~120 KB, which can overflow an agent context. Counts, outcomes_summary and representatives are complete-result regardless of page size - set page.limit 1-5 unless you need row-level evidence, then page with next_page. PROJECTION: counts_by_symbol lists only instruments with at least one match; the number of zero-count instruments omitted is stated in a trailing note (absence = 0 matches, not missing data). Pass full_counts: true for the engine's verbatim canonical bytes with every zero entry.
| Name | Required | Description | Default |
|---|---|---|---|
| document | Yes | A complete research_query.v2 document (target record_occurrences, stated chips only). Call list_features for the grammar; do not invent field names. | |
| full_counts | No | True returns the engine's verbatim canonical bytes, including every zero-count instrument in counts_by_symbol (~150 KB+ for universe scans). Default omits zero-count entries and states how many were omitted. | |
| if_none_match | No | An ETag from a previous run to revalidate: identical data answers 304 and spends nothing. Pass it back verbatim (it may be weak, W/"..."). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description richly discloses behavioral traits beyond the readOnlyHint and openWorldHint annotations: caching and 304 revalidation behavior, absence of horizons in outcomes_summary, context size overflow risks, zero-count omission semantics, contract to echo document/key, and the OUTCOME_IN_PREDICATE error. No contradiction with annotations; in fact it elaborates on the read-only, cache-friendly nature.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense and front-loaded, starting with the core purpose before diving into caveats. While lengthy, every sentence adds value for a complex tool. A slight structural improvement could be collapsing some repeated warnings, but it is well-organized and not redundant.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Without an output schema, the description fully explains return values, the meaning of outcomes_summary across horizons, the role of page rows as examples, and the caveat about absent horizons. It also covers size limits, pagination, and zero-count handling—everything an agent needs to correctly invoke and interpret results.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Despite 100% schema coverage, the description adds significant meaning beyond the schema: the document must contain 'stated chips only', full_counts returns 'verbatim canonical bytes' with size implications, and if_none_match is a weak ETag that can be revalidated. It also provides crucial domain semantics (e.g., exact lowercase Binance symbols) that the schema's brief descriptions lack.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action: 'Execute a research_query.v2 document over the deterministic engine' and enumerates the outputs (counts, denominators, outcomes_summary, reproducibility key, page-1 rows). It distinguishes this from sibling tools by explicitly naming interpret_prose, list_features, next_page, and run_cohort as alternatives for different needs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit when-to-use guidance: use interpret_prose first for prose input, call list_features for grammar, use next_page for row-level evidence, and set page.limit 1-5 unless needed. It also clarifies when to pass full_counts: true and explicitly warns against filtering outcome fields. This is strong usage guidance with named alternatives and exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read the engine registry AS-OF the grid bucket containing a moment: every feature value, the closed-list window aggregates, and the fired rulebook ids, as the engine's canonical bytes. A read, never a scan (not credit-metered). Use it to turn one observed moment into candidate clauses, then run_scan to find every other time it looked like that. Selection discipline: if you picked the moment because it moved, expect the follow-up scan to deflate over all occurrences. That is the product working. TIERS (2026-07-31): reading the CURRENT minute is free on every key. Reading a PAST minute is a Pro feature and answers 403 GRANT_REQUIRED on a free account - the record is the paid part, and the error body carries the upgrade URL. Ask for the present when you only need what is true now; ask for a past minute when you need the record.
| Name | Required | Description | Default |
|---|---|---|---|
| at | Yes | An RFC3339 datetime; the engine floors it to the grid bucket that contains it. | |
| symbol | Yes | Lowercase perp, e.g. btcusdt. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint and openWorldHint annotations, the description discloses that the operation is 'never a scan (not credit-metered)', explains tier-based access restrictions (past-minute reads are Pro, returning 403 with an upgrade URL), and notes that results are canonical bytes. This adds meaningful behavioral context beyond what annotations provide.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Although the description is longer than typical, every sentence adds actionable information: the read-only/credit distinction, the connection to run_scan, the deflation warning, and the tier/error details. The TIERS section is clearly separated and front-loaded with the core purpose in the first sentence, so the structure is efficient and purposeful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description compensates by listing the exact contents of the returned snapshot (feature values, window aggregates, fired rulebook ids) and describing the canonical-byte format. It also covers the access model (free/present vs. paid/past), error behavior, and its relationship to run_scan, making it complete for an agent to decide when and how to invoke it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully explains both parameters (symbol as lowercase perp, at as RFC3339 datetime floored to grid bucket). The description does not add parameter-specific semantics beyond restating the 'as-of' grid-bucket concept, which is already implied by the schema. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Read') and resource ('engine registry AS-OF the grid bucket containing a moment'), and states the exact contents returned (every feature value, window aggregates, fired rulebook ids). It also explicitly distinguishes itself from run_scan, which is the primary sibling, by noting it is a read, never a scan.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives explicit when-to-use guidance: 'Use it to turn one observed moment into candidate clauses, then run_scan to find every other time it looked like that.' It also provides selection discipline for choosing moments and clear tier-based guidance on when to query present vs. past minutes, including the 403 GRANT_REQUIRED behavior on free accounts.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.2.5base_ratecommonalityget_reportinterpret_proselist_featureslist_instrumentsnext_pagerun_cohortrun_scansnapshot_atScored across 10 tools
Each tool serves a distinct role: registry/introspection (list_features, list_instruments), query execution (run_scan, run_cohort, base_rate), context utilities (snapshot_at, commonality), report retrieval (get_report), and pagination (next_page). Even run_scan vs run_cohort are clearly differentiated by the baseline comparison and sequence restriction. Descriptions are detailed and clarify edge cases, leaving no ambiguity about which tool to select.
Most tools follow a consistent verb_noun snake_case pattern: list_features, list_instruments, interpret_prose, run_scan, next_page, snapshot_at, get_report, run_cohort. However, 'commonality' and 'base_rate' are noun-style names that break the verb-first convention, creating minor inconsistency. The names are still readable and not chaotic.
With exactly 10 tools, the server is well-scoped for a research/backtesting domain. Each tool covers a necessary functionality without redundancy, and the count sits comfortably in the ideal 3–15 range. No tool feels superfluous or missing.
The tool surface covers the full research workflow: understanding the schema (list_features), instrument universe (list_instruments), translating prose to queries (interpret_prose), executing scans (run_scan) and cohorts (run_cohort), simple prevalence (base_rate), point-in-time snapshots (snapshot_at), intersection analysis (commonality), pagination (next_page), and report retrieval (get_report). This is a complete lifecycle with no dead ends or obvious gaps.
Read-only MCP server for The Quiet Protocol's engines, benchmarks, proof, and business data.
Hosted Hyperliquid MCP server: query OHLCV, funding and positioning data in plain language with a free API key.
Live prices, perps, prediction markets and a paper trading desk over one MCP.
Hosted MCP for Kalshi prediction markets: search, odds, order books, settlement rules, and trading.
