Buy cited, filing-grounded equity research per call over x402 — quarterly quantitative and qualitative cards on hundreds of tickers and growing, fiscal year-end WACC builds, and live 10-Q highlights for any US ticker — with no account and no API key.
Scored across 7 tools
Each tool serves a distinct purpose: coverage checks, line-item trajectories, sample cards, filing bundles, product terms, payment flow, and full catalog listing. Although check_10q_coverage and list_research both involve product discovery, one is a targeted availability check while the other is a comprehensive catalog, so no two tools have ambiguous roles.
Most tools follow a consistent verb_noun snake_case pattern (check_, get_, list_), with all retrieval tools using get_. The one exception is how_to_pay_x402, which uses a descriptive phrase rather than verb_noun, but it is still clearly readable and does not introduce significant inconsistency.
Seven tools is well-scoped for an equity research server that provides discovery, free samples, payment details, and catalog browsing. This is neither too thin nor bloated, and each tool has a clear role in the workflow.
The surface covers discovery, payment terms, free sample data, filing bundles, line-item trajectories, and catalog listing. A minor gap is the absence of a direct tool to retrieve the paid 10-Q highlight extractions themselves—only coverage checks and payable URLs are provided—but this is likely handled via external HTTP routes after payment, so the set is nearly complete for its stated purpose.
Free coverage check against SEC EDGAR for any U.S. ticker: confirms whether 10-Q Highlights can serve it, lists available fiscal periods (newest first), and returns the payable URLs. No charge; the paid product is the extraction itself.
| Name | Required | Description | Default |
|---|---|---|---|
| period | No | Optional fiscal period like fy2026-q1; checks that this dated variant exists | |
| ticker | Yes | U.S. ticker symbol, e.g. AAPL |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the tool readOnlyHint=true, and the description adds useful behavioral context: it queries EDGAR, orders periods newest-first, and returns payable URLs at no charge. It does not discuss failure modes or rate limits, but that is not required for a simple read-only lookup.
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?
One dense, front-loaded sentence conveys source, scope, outputs, and pricing with no filler. The free-vs-paid distinction is stated at the end without bloating the definition.
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?
For a two-parameter read-only check with no output schema, the description covers what the call does, what it returns, and the key limitation (U.S. tickers). An agent has enough to select and invoke it appropriately.
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%, and the parameter descriptions already explain ticker and the optional period format. The tool description mainly restates the overall purpose rather than adding parameter-level detail beyond the schema.
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 names the exact action (coverage check), the data source (SEC EDGAR), the target (any U.S. ticker), and the outputs (availability, fiscal periods, payable URLs). It clearly distinguishes this pre-purchase check from the paid extraction product.
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 frames the tool as a no-charge coverage check and contrasts it with the paid product (the extraction itself), telling the agent when to use it and when not to. The U.S.-ticker scope is also stated as an inclusion condition.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Three fiscal years of income statement, balance sheet and cash flow lines for one company, in one standard layout, scaled to revenue, with per-year slopes where computed. Levels and slopes only. AMD and AVGO return the COMPLETE sheet free, in the exact schema every paid sheet uses. Any other covered ticker returns its payable URL and x402 terms ($0.05 per call). Tickers outside the covered list return not_covered.
| Name | Required | Description | Default |
|---|---|---|---|
| ticker | Yes | A covered ticker, e.g. AMD (free), AVGO (free) or AAPL (paid) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With readOnlyHint=true, the tool is known to be read-only. The description adds valuable behavioral context: it discloses that AMD and AVGO get the full sheet for free, other tickers are paid with specific terms, and uncovered tickers return not_covered. This goes beyond the annotation, though it doesn't detail the exact return structure or URL format.
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 concise but information-dense, covering content, layout, scaling, free vs paid, and error handling in a few sentences. It is front-loaded with the core purpose and uses clear formatting.
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 the simple parameter set (one ticker), high schema coverage, and read-only annotation, the description adequately explains what the tool does, the different tiers of access, and what happens for uncovered tickers. No output schema exists, but the description provides enough context for an agent to call it 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%, and the description reiterates the ticker parameter with examples of free and paid tickers, which adds slight value beyond the schema. Since the schema already describes the parameter, a baseline of 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 provides a line-item trajectory sheet with three fiscal years of income statement, balance sheet, and cash flow lines for one company. It distinguishes itself from siblings by emphasizing the standard layout and scaling, and mentions the free sheets for AMD and AVGO.
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 explains when to use the tool (for any covered ticker) and gives specific examples of free vs paid tickers, but it does not explicitly mention alternatives or when not to use this tool. It implies usage through the coverage check but could be more explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Exact x402 payment terms for one payable URL or product path (price, asset, network, payTo, scheme). The live 402 response's PAYMENT-REQUIRED header remains the authoritative terms document; this tool mirrors the same constants the gates are built from.
| Name | Required | Description | Default |
|---|---|---|---|
| product | Yes | A payable path or URL, e.g. /10q-highlights/AAPL, /wacc-build/AAPL/fye-2025-09-27, /quarterly-quant-card/AMD/fy2026-q2, /quarterly-qual-card/AMD/fy2026-q2, /profiles/100x-floor, /5x-stock-empirical-profile |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations include readOnlyHint=true, which already signals a non-mutating operation. The description adds useful context: the tool mirrors the same constants the x402 gates are built from, and the live response header remains authoritative. This clarifies the data source and its relationship to the live 402 response, which is beyond the annotation. However, it doesn't disclose details like error behavior for invalid paths, or whether terms may change over time.
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 sentences, dense with information: the first defines the output, the second sets expectations about authority. No filler, key details 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?
For a simple one-parameter read-only tool, the description is nearly complete. It explains what the tool returns, the scope (one payable URL or product path), and the relationship to the authoritative header. Missing minor context: there's no output schema, so return-format specifics beyond the field list are absent, and there's no mention of error cases or prerequisites. But given the low complexity, the description covers what an agent needs.
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% — the only parameter, product, is described with several concrete examples. The description adds that the parameter should be a payable URL or product path, which reinforces the parameter semantics but doesn't add a lot beyond the schema's examples. Baseline of 3 is appropriate because the schema already covers the parameter well.
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 name and title already convey the resource, but the description sharpens it: 'Exact x402 payment terms for one payable URL or product path (price, asset, network, payTo, scheme).' This gives a specific verb (get/exact) and a concrete resource (payment terms for a product path), and enumerates the fields returned. It doesn't explicitly differentiate from siblings like how_to_pay_x402, but the emphasis on exact constants versus a guide is reasonably clear.
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 implies the use case: retrieving the exact payment terms for a payable URL. It also gives a valuable usage steer: 'The live 402 response's PAYMENT-REQUIRED header remains the authoritative terms document; this tool mirrors the same constants the gates are built from.' This tells the agent when the tool is authoritative and when to prefer the live header. It doesn't explicitly say when to use check_10q_coverage or list_research instead, but the scoping to a single product path is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
One COMPLETE quarterly card, free — the identical payload the paid route returns for that card, not a trimmed preview. Two company-quarters (AMD fy2026-q2, MRVL fy2027-q2) are published free in both the quantitative and qualitative families, in the exact schema and field names every paid card uses, so a parser written against a sample works unchanged against any card you buy. Use it as a zero-cost integration test before paying for coverage. Any other ticker returns not_a_sample.
| Name | Required | Description | Default |
|---|---|---|---|
| family | No | Which card family to return. Defaults to quantitative. | |
| ticker | Yes | AMD or MRVL — the two company-quarters published free |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already signals safety, and the description adds valuable non-obvious behavior: the returned payload is identical to the paid card, parser-compatible across paid cards, and invalid tickers return a literal not_a_sample sentinel. 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?
Every sentence earns its place: completeness guarantee, free sample set, parser compatibility, recommended use case, and invalid-input behavior. The core promise is front-loaded in the first sentence.
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?
For a simple read-only tool with one required parameter and no output schema, the description fully covers what is returned, which inputs are valid, why the response is trustworthy, and what happens on failure. Nothing essential is missing.
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 schema already documents the ticker and family parameters with 100% coverage, so the baseline is 3. The description adds meaningful extra semantics by guaranteeing identical schema and field names for all paid cards and by specifying the exact invalid-ticker sentinel, which helps an agent reason about the ticker parameter's 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?
States a specific verb and resource: returns one complete quarterly card, and specifies the exact free samples (AMD fy2026-q2, MRVL fy2027-q2) and families. It explicitly contrasts with the paid route and clarifies this is not a trimmed preview, making its purpose unmistakable.
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?
Gives an explicit use case: use as a zero-cost integration test before paying for coverage. It also names the paid route as the alternative and sets a clear boundary: any non-sample ticker returns not_a_sample.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
One company's SEC 10-K or 10-Q as a ZIP: the filing HTML as filed, the three consolidated statements in a workbook (IS, BS, CF) exactly as rendered, a manifest naming the accession, and a pointer to the quarterly cards for the same filing. Source material only; nothing inferred. Lists every bundle held for the ticker with its free manifest URL; AMD, MRVL, AVGO and MRCY are free in full. Other bundles return their payable URL and x402 terms ($0.05 each). Tickers with no bundle return not_covered. The ZIP bytes themselves are only served over the HTTP routes.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | No | Optional bundle slug like 10q-2026-06-27 or 10k-2026-07-03; defaults to listing every bundle held for the ticker | |
| ticker | Yes | U.S. ticker, e.g. AMD (free), AAPL (paid) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint annotation, the description adds rich behavioral context: it is source material only with nothing inferred, some bundles are free while others require x402 payment terms, unknown tickers return not_covered, and ZIP bytes are only served via HTTP routes. This fully discloses delivery and access behavior an agent needs.
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 every sentence adds operational value: bundle contents, free tickers, payment terms, not_covered behavior, and delivery constraints. It is somewhat long but appropriately front-loaded with the core definition before the pricing and delivery details.
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 carries the burden of explaining return values, and it does: manifest URL, workbook contents, quarterly-card pointer, payable URLs, x402 terms, and not_covered. It gives enough detail for an agent to know what to expect and how to invoke the tool 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 covers 100% of parameters, so the baseline is 3. The description adds meaningful semantics by explaining the slug's default behavior ('defaults to listing every bundle held for the ticker') and giving concrete slug/ticker format examples, which helps the agent construct valid calls.
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 states a specific verb ('Find'), a specific resource (SEC 10-K / 10-Q filing bundle), and enumerates the bundle contents: filing HTML, consolidated statements workbook, manifest, and quarterly-card pointer. It also explicitly differentiates itself by describing free vs. payable tickers and the not_covered case, making its scope unmistakable.
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 when this tool is appropriate — retrieving a full filing bundle for a ticker — and explains the default behavior when no slug is provided. It does not explicitly name sibling alternatives or state when not to use it, so it stops 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.
The x402 payment flow for these products, the client libraries that automate it, and where the authoritative terms live.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already signals a safe read-only operation, so the description does not need to restate that. The description adds useful scope about payment flow and libraries but does not disclose what the tool actually returns or how the information is delivered.
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 compact sentence with no filler. It could be slightly improved by adding a verb, but every phrase currently included adds relevant 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?
For a parameterless, read-only informational tool, the description covers the essential topics: the payment flow, libraries, and authoritative terms. It does not specify the output format, but the lack of parameters and the narrow scope make this a minor gap rather than a critical omission.
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 no parameters and an empty input schema, so parameter guidance is unnecessary. The description appropriately focuses on the tool's content rather than parameters.
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 identifies the subject: the x402 payment flow, client libraries, and authoritative terms. It is not a tautology and is distinguishable from siblings like check_10q_coverage or get_product_terms, but it lacks an explicit action verb such as 'returns' or 'explains'.
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 does not state when to use this tool or when to prefer a sibling. There is no mention of scenarios for paying, searching terms, or retrieving research, so the agent must infer usage from the title and topic.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
The full alpha402x catalog: every payable research product (empirical multibagger profiles, fiscal-year-end WACC builds, 10-Q highlight extractions, quarterly quantitative and qualitative cards) with prices, payable URLs, and free guide pages. All prices are USDC per call over x402.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only declare readOnlyHint=true. The description adds beyond that by specifying that the response covers every payable product, includes prices and payable URLs, and clarifies that all prices are USDC per call over x402. That is useful behavioral/commercial context; pagination or response shape is not disclosed, but it is acceptable for a simple list operation.
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?
One dense, front-loaded sentence states the scope first ('The full alpha402x catalog'), then enumerates the product categories and closes with the pricing detail. Every clause adds relevant information and there is no filler.
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 needs to convey what the response will contain, and it does: products, prices, payable URLs, and free guide pages. It could go slightly further by describing the response format or field structure, but for a zero-parameter read-only catalog listing this is sufficiently complete.
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 parameter semantics are trivially clear and the baseline is 4. There is no schema to enrich and no parameter ambiguity to resolve.
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 names the resource ('alpha402x catalog'), picks a specific verb ('list'), and enumerates the content areas (empirical multibagger profiles, WACC builds, 10-Q extractions, quarterly cards). This makes it readily distinguishable from sibling tools like check_10q_coverage or get_product_terms.
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 intended use is implied strongly: an agent that needs an overview of payable research products with prices should call this tool. However, it does not explicitly contrast itself with alternatives or state when not to use it, leaving some routing to inference rather than guidance.
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.
get_sec_filing_bundleget_line_item_trajectoryget_sample_cardcheck_10q_coverageget_product_termshow_to_pay_x402list_research
Add one secure layer between your agents and this server.