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
Most tools target clearly distinct resources: coverage checking, trajectory data, sample cards, filing bundles, catalog listing. The three payment/catalog-adjacent tools (get_product_terms, how_to_pay_x402, list_research) have some conceptual overlap that could occasionally cause misselection, but each has a distinguishable function.
Names predominantly follow a predictable snake_case verb_noun pattern (check_10q_coverage, get_line_item_trajectory, get_sample_card, list_research). The main deviation is how_to_pay_x402, which uses a phrase-style name rather than verb_noun, but it remains readable and descriptive.
Seven tools is well-scoped for a research-product discovery and sampling service. Each tool earns its place, covering discovery, free samples, terms, and payment guidance without redundancy.
The surface covers discovery (list_research, check_10q_coverage), free sampling (get_sample_card), terms (get_product_terms, how_to_pay_x402), and source material (get_sec_filing_bundle). Actual paid card/highlight retrieval is intentionally served over HTTP x402 routes rather than MCP, so agents must leave the tool surface to transact—a minor but workable gap.
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 SEC-rendered consolidated statements in a workbook (IS, BS, CF where present; the manifest names the sheets, and a two-sheet workbook is disclosed on the bundle), 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?
Goes well beyond the readOnlyHint annotation: discloses pricing and x402 terms, the free-ticker set, the not_covered outcome for uncovered tickers, and critically that the ZIP bytes themselves are only served over HTTP routes rather than returned inline. These are exactly the operational facts an agent needs before invoking.
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?
Front-loads the core deliverable, then layers contents, pricing, and edge cases. Nearly every clause carries information, though the middle sentence is dense and could be split for readability.
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 return-shape burden and does reasonably well: it names the manifest, workbook, quarterly-card pointer, the payable URL, and the not_covered sentinel. Coverage of what a successful vs uncovered response looks like is sufficient for correct invocation.
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 documents ticker and slug semantics. The description adds little parameter-level detail beyond the manifest-listing default that the schema also states, so baseline 3 applies.
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: one company's SEC 10-K/10-Q delivered as a ZIP, with an explicit inventory of contents (HTML, workbook, manifest, quarterly-card pointer). An agent can tell what it gets. It does not, however, explicitly contrast itself with the closest sibling, check_10q_coverage, so it falls short of a 5.
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 useful selection context (free tickers AMD/MRVL/AVGO/MRCY, paid bundles at $0.05, not_covered when nothing exists) but never states when to choose this over check_10q_coverage or get_line_item_trajectory. Usage is implied by resource type rather than stated as a rule.
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.