DeltaSignal ATLAS-7

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description goes well beyond the readOnlyHint/idempotentHint annotations by disclosing concrete behaviors: three internal HTTPS reads, preservation of partial results on failure, never calls issuer-level tool, and the default operating-company issuer filter. This adds meaningful operational context that annotations alone do not 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?

The description is information-dense yet each clause serves a purpose: purpose/scope, internal call plan, parameter constraints, behavior, and usage triggers. No filler or redundancy; it efficiently packs critical guidance into three sentences.

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 composite tool with only one parameter and a rich output schema, the description fully covers what the tool does, how it behaves, when to use it, and how to interpret results. It also handles edge cases (partial failures, prohibited params) which is more than sufficient for an agent to invoke 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% for the single output_mode parameter, giving a baseline of 3. The description adds valuable guidance by explicitly restricting to 'compact only' and prohibiting other common parameters (limit, offset, ticker, etc.) because the preset owns them, which helps the agent avoid passing invalid arguments.

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: 'composite workflow tool for opportunity and alpha screening across the current DeltaSignal issuer universe.' It distinguishes from siblings by emphasizing the server-enforced preset call plan (readiness, alpha_opportunities with limit 15, daily_changes), making it clear this is an aggregated sweep rather than a single-purpose 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?

Provides explicit invocation conditions: 'Use it when the user asks for alpha opportunities, opportunity sweep, clean alpha board, or names worth follow-up research.' It also warns against passing limit/offset/ticker/issuer filters because the preset owns arguments, and clarifies the result is a screen requiring issuer drilldown, implying when to switch to other tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations declare readOnlyHint, idempotentHint, and destructiveHint=false; the description reinforces this and adds domain-specific context: 'it has no destructive side effects and performs no wallet, settlement, or trading actions.' It also clarifies that it 'assembles one calculation-history row from the existing ATLAS-7 precomputed surfaces,' indicating no computation or side effects. This adds value beyond the generic hints.

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 compact—three sentences that cover purpose, components, parameters, behavior, and usage context. The first sentence is goal-oriented and each subsequent sentence adds distinct information without redundancy. The long component list is dense but necessary for completeness.

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 tool's complexity (8 parameters, many bundled surfaces), the description covers the essential context: what it does, how to filter (ticker/CIK/date range), what mode does, and its read-only safety profile. The existence of an output schema relieves it of explaining return values. It could mention limit/offset defaults, but the schema already covers those.

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 has 100% description coverage, but the description adds relational meaning: 'source_date replays one YYYY-MM-DD ATLAS-7 slice', 'source_date_from/source_date_to can page recent slices', and 'ticker or CIK narrows to one issuer.' It also explains the mode parameter's effect ('compact by default and full includes source_fields_json'). This goes beyond bare parameter names.

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 opens with a specific instruction: 'Use this read-only tool when agents need the complete ATLAS-7 calculation bundle for an issuer and source_date.' It names the resource ('complete ATLAS-7 calculation bundle'), the verb ('assembles'), and enumerates the included surfaces (covenant stress, company fundamentals, peer ranking, alpha signals, etc.). This distinguishes it from narrower sibling tools by emphasizing completeness and the historical, point-in-time context.

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 states when to use: 'when agents need the complete ATLAS-7 calculation bundle for an issuer and source_date' and 'Use this before historical report rendering so agents do not mix latest-only fields into a historical answer.' It does not explicitly name alternative tools or state when not to use it, but the historical-report context provides a clear usage boundary.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare read-only, idempotent, and non-destructive hints; the description reinforces these and adds key behavioral context: it never returns the raw facts_payload and directs users to fact_source_pointer/evidence_hash for deeper inspection. 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 four dense sentences with no filler, front-loading the purpose, then parameters, behavior, and use case. Each sentence earns its place given the tool's 7 optional parameters.

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 an output schema present, the description doesn't need to detail return values. It covers the purpose, usage context, parameter behavior, and key constraints (no raw payload, universe size of 215), making it complete for a read-only retrieval 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%, so baseline is 3. The description adds valuable semantic context beyond schema by explaining source_date as replaying a materialization slice, ticker/cik narrowing to one issuer, limit capping at 250, and offset paginating. It does not mention mode or include_summary, but those are self-explanatory in 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?

Clearly states it retrieves compact SEC CompanyFacts/XBRL materialization rows for the crypto public-company universe, with a specific verb (retrieve) and resource. It distinguishes itself from sibling tools by specifying the issuer-level inventory and materialization slice concept.

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 says when to use this tool ('for Mirror Pulse or ATLAS-7 historical joins') and what to use instead for drilldown/audit (fact_source_pointer plus evidence_hash), providing clear alternatives and exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already mark read-only, idempotent, and non-destructive, but the description adds substantial behavioral context: it does not fetch live market data, run ATLAS calculations, place trades, or mutate recorder state. It also explains the conceptual guarding behavior ('without promoting legacy compatibility scores or venue context into canonical truth'). This exceeds the annotation baseline.

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 well-structured: a purpose statement, a list of reported layers, a parameter summary, and behavioral notes. Every sentence earns its place, though the second sentence is slightly long and dense. It is appropriately sized for the tool's complexity and front-loaded with the primary use case.

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 output schema exists and the annotations cover safety, the description provides all necessary context: scope (single issuer or paginated universe), the four output levels, parameter options, pagination behavior, and explicit non-behaviors. It is complete for an agent to select and 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 schema already documents all six parameters with descriptions and constraints, providing 100% coverage. The description's parameter list adds no new semantic detail beyond what the schema provides. Baseline 3 is appropriate because the schema carries the burden and the description does not need to compensate.

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: determining which ATLAS-7 four-level layers are evidence-backed for one issuer or a paginated universe. It names the specific output levels (Level 1-4) and distinguishes itself from likely siblings by explicitly noting it does not promote legacy compatibility scores or venue context. This is a specific verb+resource+scope statement, with enough detail to differentiate from adjacent 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?

The description gives clear context on when to use the tool: for evidence-backed ATLAS-7 layer assessment on a single issuer or paginated universe, in read-only mode. It does not explicitly name alternative tools or state when not to use it, but the scope and behavior are well-defined. This earns a 4 rather than 5 due to the absence of explicit exclusions or alternative-tool references.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond annotations (readOnlyHint, idempotentHint), the description details that it performs one HTTPS read, has no destructive side effects, does not generate Natural Language, and never executes trades, wallets, or settlement flows. It also explains point-in-time recomputation logic and lookahead safety flags, adding significant behavioral 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?

The description is well-structured and front-loaded with purpose, then methodology, then parameters and behavior. It is somewhat long because it restates parameter names already present in the schema, but every sentence adds useful context, so it is not wasteful.

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 that an output schema exists and annotations are rich, the description covers purpose, methodology, behavior, and mode selection. It is complete enough for an agent to invoke the tool correctly without needing to infer additional context.

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?

With 100% schema description coverage, the baseline is 3. The description lists parameter names but adds no new semantic meaning beyond the schema, except for the 'mode' defaults and usage advice, which is already partially in 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 clearly states the tool returns daily ATLAS-7 CompanyFacts-derived factor rows keyed by as_of_date, with a specific methodology (filed <= as_of_date) that distinguishes it from other history tools. It also names concrete use cases (Mirror Pulse, backtests, agents), making the 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?

It explicitly says to use this tool when Mirror Pulse, backtests, or agents need daily factor rows, giving clear context. It also provides mode selection guidance (compact for joins, full for audit pages) but does not name alternative tools or explicitly state when not to use it, so a 4 rather than 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the read-only, idempotent, and non-destructive annotations, the description discloses that it performs one HTTPS read, has no destructive side effects, and does not apply the latest ATLAS snapshot retroactively across history. This is substantive behavioral context that helps an agent anticipate side effects and temporal semantics.

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 organized into purpose, return shape, parameters, behavior, and use cases in a compact paragraph. Each sentence adds distinct value and front-loads the most important 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 the rich input schema, annotations, and output schema, the description adequately covers purpose, return row content, parameter semantics, behavior, and use cases. It is complete for an agent to select and 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 has 100% description coverage with detailed parameter descriptions, including defaults/caps, date formats, and inclusive bounds. The tool description only summarizes these parameters and adds no additional semantic detail, so the 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 identifies a specific verb ('retrieve'), a resource ('historical ATLAS-7 covenant and stress series'), and a scope ('one crypto public company ticker'). It distinguishes this tool from sibling tools by emphasizing dated ATLAS source-date rows and mNAV/Mirror Pulse joins.

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 states when to use the tool: historical ATLAS data, MSTR/Strategy time series, mNAV backtests, Mirror Pulse joins, and dated stress/risk snapshots. It does not name sibling alternatives or when-not conditions, so the guidance is clear but not comparative.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly, idempotent, and non-destructive. The description adds valuable context by specifying the data source (persisted recorder evidence), the output's venue-pure nature, and explicit exclusions (no live exchange data, no trading, no recorder mutation). This goes beyond the annotations but does not mention error conditions or rate limits.

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 three sentences with no fluff: it front-loads the purpose, summarizes return content, lists parameters, and clarifies behavior. Every sentence earns its place.

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 output schema exists and annotations cover safety, the description is complete. It explains the tool's scope, output composition, parameter options, and non-behaviors, making it sufficient for an agent to select and invoke 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 description coverage is 100%, and the description merely lists parameter names and modes without adding deeper meaning. The schema already documents each parameter well, including examples, so the description adds little beyond restating them.

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 retrieves Coinbase INTX perp market-factor history from persisted recorder evidence, with a specific listing of returned fields (contract identity, ATLAS-shaped factors, deltas, quality state). This distinguishes it from siblings like deltasignal_coinbase_perp_factors or deltasignal_coinbase_perp_rankings by emphasizing calculation-history rows.

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: a read-only historical retrieval tool that does not fetch live data or place trades. However, it does not explicitly name alternative tools or provide when-not-to-use conditions, 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.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds meaningful context: it returns 'additive curated constituent overlays grouped by source date', preserves the 'evidence boundary' of persisted registry rows, and explicitly states it does not fetch live exchange data, place trades, or mutate recorder state.

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 three sentences, front-loaded with the core purpose, and every sentence conveys essential information without redundancy or fluff.

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 read-only nature, the presence of an output schema, and rich annotations, the description covers the necessary behavioral constraints, parameter options, and evidence-boundary nuance. It is complete for an agent to select and 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?

Schema description coverage is 100%, so each parameter is already documented. The description restates required product and optional filters (source_date, source_date_from/to, mode, limit, offset) but does not add 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 states a specific verb+resource: 'retrieve persisted constituent registries for one Coinbase thematic or index perp product'. It also distinguishes itself by clarifying these are 'persisted registry rows rather than live exchange-native constituent APIs', which differentiates 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?

The description clearly establishes when to use the tool ('Use this read-only tool...') and excludes live data fetching, trade placement, and recorder mutation. However, it does not explicitly name alternative tools for those use cases, 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.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is known. The description adds valuable context beyond annotations: it explicitly states the tool 'does not fetch live exchange state or write recorder artifacts on demand,' and clarifies that the data is 'persisted' and 'venue-pure.' This enriches the behavioral model without contradicting 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 compact (four sentences) and well-structured: opening use-case statement, return content, parameter overview, and behavioral note. It front-loads the most important information and avoids redundancy with the schema. Every sentence contributes useful context, making it a model of concise tool documentation.

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 tool has a rich output schema and fully documented parameters, the description need not repeat return details. It covers the core purpose, output components, optional modes (compact/full), and behavioral constraints. Minor gaps remain, such as not clarifying the relationship between source_date and source_date_from/to, but overall it is sufficiently complete for an agent 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?

Schema description coverage is 100%, and each parameter already has a detailed description in the schema. The description merely lists parameter names (product, source_date, source_date_from/to, underlying_ticker, mode, limit, offset) without adding new semantics, such as mutual exclusivity or mode differences. Baseline 3 is appropriate because the schema carries the parameter documentation burden.

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 ('returns') and resource ('persisted Coinbase INTX market-factor history for one perp product'), and lists concrete output contents (factor rows, deltas, quality state, optional full market inputs or lineage). It clearly distinguishes this tool from sibling tools like calculation_history or rankings by emphasizing 'venue-pure factor history' for a single 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 opens with an explicit when-to-use statement: 'Use this read-only tool when the user wants persisted Coinbase INTX market-factor history for one perp product.' It also clarifies what it does not do (fetch live exchange state, write recorder artifacts). However, it does not name alternative sibling tools or provide explicit when-not-to-use guidance, so it falls just short of a full 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly, idempotent, and non-destructive; the description adds specific behavioral detail by describing the transformation ('converts persisted market-factor history into field pressure...') and explicitly stating what it does NOT do (create factors, reconstruct depth, override rows). This adds substantial context beyond the generic hints.

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 compact and front-loaded. It states the purpose, then the process, then parameters, then behavior, without redundant or unnecessary sentences. Every phrase adds value.

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 output schema exists, return values need not be described. The description covers purpose, transformation, parameter summary, and limitations (read-only, no side effects). It is complete for an agent to select and 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?

All 6 parameters have detailed schema descriptions, so the baseline is 3. The description adds a useful clarification that source_date is an alternative to source_date_from/source_date_to, implying mutual exclusivity, which is not explicitly stated in the schema. This small addition justifies 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 a specific action ('retrieve the market SPECTRA field map') and a specific resource ('one Coinbase INTX perp product'). It distinguishes from siblings by emphasizing the Coinbase perp-focused scope and the conversion process into labels.

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 opening 'Use this read-only tool to...' provides clear context for when to use it. It also includes exclusions via 'does not create factors, reconstruct missing depth, or override the underlying factor rows,' but it does not explicitly name alternative tools or contrast with siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Although annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, the description adds valuable context: 'read-only and idempotent with no destructive side effects; it performs no live exchange fetches, order placement, or settlement flows.' This goes beyond annotations by explicitly reassuring the agent that no live market interactions occur, which is important for a ranking tool. It also mentions 'latest persisted market_alpha row' and output fields, further clarifying behavior.

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 three sentences: purpose, return shape, and parameters/behavior. It is front-loaded with the most important information, and every sentence earns its place. No unnecessary detail or repetition of the title.

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 covers the tool's core function, output structure, filter options, and safety profile. Since an output schema exists, return values are already documented, so the description does not need to list every field. It is sufficiently complete for an agent to decide when and how to invoke this tool, given the rich schema and annotations.

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 every parameter has a description. The description simply lists the parameter groups ('optional product or underlying_ticker filters, source_date or source_date_from/source_date_to, mode=compact|full, limit, and offset') without adding new meaning or clarifying relationships beyond the schema. This meets the baseline but does not elevate it.

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: 'rank Coinbase INTX perp products by the latest persisted market_alpha row per product.' It uses a specific verb ('rank') and resource ('Coinbase INTX perp products'), and the unique focus on 'latest persisted market_alpha row' and the ranking board output distinguishes it from siblings like deltasignal_coinbase_perp_factors or peer_ranking.

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 clear context by saying 'Use this read-only tool to rank...' and enumerates optional filters and modes, implying when it's appropriate. It does not explicitly name alternatives or exclusions (e.g., when to use a different rankings tool), but the context is sufficient for an agent to infer typical use cases.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Even though annotations already provide readOnlyHint, idempotentHint, and destructiveHint, the description adds valuable context: 'performs six internal HTTPS reads, has no destructive side effects, rejects invalid tickers before fan-out, and preserves partial results if a required issuer leg fails.' It also clarifies SPECTRA inclusion logic, which goes 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 longer than average but appropriately so for a composite workflow. It is front-loaded with the core purpose, then covers parameters, behavior, and usage in a logical sequence. Each sentence provides specific information; no wasted words.

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 tool's complexity, the presence of an output schema (so return values need not be explained), and rich annotations, the description is complete. It covers purpose, parameter semantics, internal behavior, error handling, partial results, and use cases. The agent has all necessary context to invoke 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?

The schema already has 100% coverage with descriptions for each parameter. The tool description adds extra meaning by explaining that period is passed to fundamentals, peer ranking, and covenant stress, and that include_segments/include_related_party request containers from company_fundamentals. This enhances the schema without being redundant.

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 this is a read-only composite workflow tool for the default full single-issuer DeltaSignal ATLAS-7 company report. It enumerates the included components (readiness, company_fundamentals, alpha_signals, etc.) and explicitly contrasts with low-level tools for custom drilldowns, making it distinguishable 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?

The description provides explicit when-to-use guidance: 'Use it when the user asks for a report, deep dive, issuer brief, or diligence package on one crypto public-company ticker, or when a Morning Brief top-stressed or alpha-screen row needs a separately sold explanation report.' It also states the alternative: 'use low-level tools only for custom drilldowns.' This clearly orients the agent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description adds significant behavioral context beyond annotations: it explicitly states the tool is read-only and idempotent, performs a single HTTPS read, has no destructive side effects, and never infers covenant breach or other sensitive conclusions unless backed by evidence. This goes beyond the annotations and is highly valuable for safe invocation.

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 well-structured and front-loaded with the use case. It covers output format, parameters, and behavior in a concise but complete manner. Every sentence adds value, and there is no redundancy or fluff.

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 is thorough for the tool's complexity. It explains output characteristics (Markdown, audit-grade, preserving data elements), parameter roles, and safety behaviors. Given the rich annotations and output schema, the description provides all necessary context for an agent to select and 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 schema has 100% coverage, so baseline is 3. The description adds nuance by explaining that the optional date parameter maps to the evidence period 'when supported,' which is helpful. However, it refers to the parameter as 'date' while the schema names it 'period,' causing slight ambiguity, so not a perfect score.

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 provide ticker-specific covenant stress evidence in human-readable Markdown. It uses a specific verb ('explained') and resource ('covenant stress evidence'), and distinguishes from siblings like the structured covenant stress tools by mentioning 'Natural Language' and 'human-readable Markdown'.

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 a clear condition for use: 'when the user wants ticker-specific covenant stress evidence explained in human-readable Markdown.' It does not explicitly mention alternatives or when not to use this tool, but the context is sufficient for selection among sibling tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already provide readOnlyHint=true, idempotentHint=true, destructiveHint=false, and the description adds concrete behavioral context: 'local and idempotent with no destructive side effects; it does not run paid analysis routes or expose internal-only tools.' This explains what the tool avoids, which is beyond the structured annotations. No contradictions.

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 earning its place: trigger conditions, parameter summary + behavior, and boundary/exclusion note. Uses 'Parameters:' and 'Behavior:' labels for internal structure. No fluff or repetition, front-loaded with the most important guidance.

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 tool is a help/discovery helper with an output schema present, the description covers purpose, parameters, behavior, exclusions, and alternative resources. It even explains it translates natural-language queries into the live DeltaSignal discovery contract, which is rich context for an agent. 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?

Schema description coverage is 100%, with every parameter already described (topic enum, detail enum, question alias, etc.). The description merely lists the parameter names and says they are optional, adding no semantics beyond the schema. Baseline 3 is appropriate because the schema fully carries parameter meaning.

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 opens with a specific verb and resource: 'Use this free read-only discovery-tier tool when the user asks for help' and enumerates exactly which topics are covered (pricing, fields, grants, etc.). It clearly distinguishes itself from sibling data tools by positioning itself as the help/orientation tool, not a data-returning 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 states explicit trigger conditions ('when the user asks for help, available commands, MCP tools, core concepts...') and also gives exclusions: 'not a trading, execution, or investment-advice tool.' It points users to specific alternatives like tools/list and /v1/pricing, and mentions that omitting all arguments gives overview help. This is exemplary when-to-use guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description details internal behavior: 'bounded internal fan-out', 'preserves partial failures', and 'explicitly reports missing evidence instead of inventing... facts'. These traits are not evident from the annotations and provide valuable transparency about execution and error handling.

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 well-structured into purpose, parameters, behavior, and usage context, with front-loaded intent. It is somewhat long due to the detailed evidence plan list, but each sentence serves a purpose. Minor redundancy exists between the opening usage statement and the final GME-style example, but overall it is efficient for a complex composite tool.

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 tool's complexity (7 parameters, composite workflow, output schema), the description covers when to use, what to expect (missing evidence reporting, partial failure handling), and what questions it answers (why a stress row exists, what changed, peer context, historical path). The output schema handles return structure, so the description is rich enough for an agent to select and 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 description adds context beyond the schema by noting that 'ticker is normalized to uppercase' and that the optional date parameters and output_mode=compact are 'reproduction controls'. This groups the parameters meaningfully and clarifies their collective purpose, though the schema already provides per-parameter 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 is a 'read-only composite workflow tool for a paid filing-backed issuer drilldown' and specifies its purpose: to provide causality for daily brief pressure or opportunity rows, not just a headline score. This distinguishes it from sibling tools that likely offer simpler score-based summaries.

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 says to use this tool 'when a daily brief pressure or opportunity row needs causality' and mentions 'GME-style paid reports' as a concrete use case. However, it does not name alternative tools or provide explicit when-not guidance, though it implies that simpler headline-score tools exist.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare read-only, idempotent, and non-destructive, but the description adds concrete behavioral details: server-enforces the full call plan, performs a bounded internal fan-out, preserves partial results if a required internal call fails, and only accepts compact output mode. This goes well beyond annotations and gives the agent accurate expectations.

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 efficiently organized: purpose, call plan, parameter constraints, behavioral guarantees, and usage scope in a logical flow. Every sentence provides necessary information, though the length is slightly higher than minimal due to the composite nature of the tool. It remains well-structured and 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?

Given the tool's composite complexity, the presence of an output schema, and strong annotations, the description is remarkably complete. It covers invocation semantics, internal call composition, failure behavior, accepted output mode, and alternative tools for drilldown, leaving no significant gaps for an agent to resolve.

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 single parameter output_mode is fully described in the schema (and the description confirms it), but the description adds crucial extra semantics by explicitly listing parameters that must NOT be passed (limit, offset, ticker, source_date, issuer filters) because the preset owns those internally. This prevents misuse that schema alone wouldn't catch.

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 is a read-only composite workflow tool for a daily scan, enumerates the exact internal call plan (readiness, daily_changes, risk_distribution, top_stressed, etc.) with limits, and distinguishes it from company-report or deep-brief drilldown tools. This is specific, action-oriented, and differentiates it from the extensive sibling list.

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 when to use it ('morning brief, daily brief, daily scan, current risk board, newsroom first-pass requests') and when not to ('sell company-report or deep-brief issuer reports separately for drilldown'). Also warns against passing conflicting parameters like limit or ticker, which is essential for correct invocation.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already state readOnly, idempotent, and non-destructive. The description adds substantial behavioral context: it 'compiles backend-composed compact evidence', 'performs the server-enforced Morning Brief workflow', 'never fans out into tools', and 'renders... as a bounded Natural Language response.' These traits are not inferable from annotations alone and provide clear expectations.

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 slightly long but well-organized: it front-loads the core purpose, then describes compilation, exclusions, parameters, and behavior in logical order. Each sentence contributes unique information, though the parameter list could be trimmed slightly without losing meaning.

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 tool's moderate complexity, rich annotations, and existing output schema, the description covers purpose, content scope, exclusions, parameter caveats, and behavioral guarantees. It does not need to cover return values because the output schema exists. The inclusion of 'never generates social drafts or trade recommendations' also contextualizes against sibling tools.

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 detailed parameter descriptions. The description adds value by noting that 'Date and limit are accepted only where the backend composite supports them,' which is a conditional not in the schema. It also restates the style enum values but does not introduce new semantics for the parameters 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 starts with a clear verb and resource: 'Use this premium read-only Natural Language tool when the user wants the server-composed Morning Brief rendered as audit-grade Markdown.' It specifies the output format (Markdown), the content categories (readiness, daily changes, etc.), and explicitly distinguishes itself from siblings by noting it never fans out into tools or generates drafts/recommendations.

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 a clear when-to-use condition ('when the user wants... rendered as audit-grade Markdown') and exclusions ('never fans out into tools', 'never generates social drafts or trade recommendations'). It also provides conditional parameter guidance ('accepted only where the backend composite supports them'). However, it does not explicitly name alternative sibling tools for comparison, so it stops short of full alternatives guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds meaningful behavioral detail: three internal HTTPS reads, preservation of partial results if one call fails, no calls to issuer-level tools, and no destructive side effects. This enriches the agent's understanding of what happens at runtime 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?

Five sentences, logically organized into purpose, call plan, parameters, behavior, and usage triggers. Every sentence contributes essential information with no redundancy or fluff. The structure is front-loaded with the core purpose before diving into 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?

For a composite workflow tool with one optional parameter and existing output schema, the description covers all critical aspects: exact internal operations, parameter restrictions, behavioral characteristics, and user-intent triggers. With annotations and output schema handling safety and return values, this is 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 schema already fully covers output_mode with a description ('Only compact is accepted'), so the baseline is 3. The tool description adds value by reiterating the constraint and explaining why other parameters are not allowed ('this preset owns exact arguments internally'), preventing the agent from attempting unsupported filters. The schema coverage is 100% and the extra contextual rationale justifies 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 is a composite workflow for risk and stress monitoring across the DeltaSignal issuer universe, and explicitly enumerates the server-enforced call plan (readiness, top_stressed with limit 15, risk_distribution). This distinguishes it from individual sibling tools like deltasignal_top_stressed or deltasignal_risk_distribution by presenting it as a preset orchestration.

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 usage triggers ('when the user asks for risk monitoring, pressure board, stress board, top stressed overview, or current risk mix') and explicitly tells the agent not to pass limit, offset, ticker, source_date, or issuer filters because the preset owns arguments. This gives clear situational guidance and implicitly points to finer-grained alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses behaviors beyond annotations: it 'server-enforces the morning brief evidence plan,' 'removes internal-only identifiers from the public copy,' 'preserves non-advice language,' and 'returns deterministic HTML plus copy_text.' It also confirms read-only and idempotent behavior, consistent 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 structured and front-loaded: purpose, parameters, behavior, and usage. While slightly long, every sentence adds essential information about scope, constraints, and output, with no wasted words.

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 covers purpose, parameters, behavior, output format, and clear usage scenarios. It explains the internal evidence plan enforcement, public-safe rendering, and the exact output fields (HTML and copy_text), making it sufficient for an agent to select and invoke this 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?

Schema coverage is 100% with a clear parameter description ('Only compact is accepted in Phase 1'). The description adds value by explicitly stating 'optional output_mode=compact only' and warning against passing other parameters, reinforcing the schema and clarifying invocation constraints.

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 is a 'read-only composite renderer for customer-facing DeltaSignal Daily Brief artifacts' that renders 'public-safe HTML brief and copy-ready text' with plain-English explanations. It distinguishes itself from siblings by emphasizing the public/customer-facing scope and the composite rendering nature.

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?

Explicit usage guidance is provided: 'Use it when the user asks for a public daily brief, customer-facing daily brief, investor-ready risk and opportunity scan, or copy-ready DeltaSignal article based on the current daily evidence.' It also specifies constraints: 'do not pass ticker, limit, offset, source_date, period, or issuer filters because this preset owns exact arguments internally,' which prevents incorrect invocations.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Despite strong annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds valuable behavioral detail beyond them: it performs three internal HTTPS reads, rejects invalid tickers before fan-out, preserves partial results if an issuer leg fails, and has no destructive side effects. This gives the agent a precise operational model.

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, logically organized paragraph that front-loads the core purpose and then adds necessary detail. Every sentence serves a purpose—delimiting scope, listing components, explaining exclusions, and stating behavior—with no fluff or redundancy.

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 tool's composite nature, the description covers purpose, usage, exclusions, parameter behavior, safety, and failure semantics. With an output schema present, it does not need to describe return values, and the annotations already declare safety, so the description is complete for an agent to select and invoke 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 schema already documents both parameters with 100% coverage, including ticker normalization and output_mode constraints. The description echoes these facts (e.g., 'ticker is required and normalized to uppercase') but does not add significant new meaning 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 clearly states the tool is a read-only composite workflow for a fast single-ticker sanity check, listing the exact sub-calls (readiness, covenant_stress, alpha_signals) and explicitly noting it excludes the full company-report payload. This distinguishes it from sibling tools like the full company report or deeper diligence 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?

It provides clear use-case guidance: 'Use it when the user asks whether one ticker is clean, stressed, actionable, or needs deeper diligence.' It also states exclusions (fundamentals, peer ranking, SPECTRA) and contrasts with the full report, though it does not name specific alternative sibling tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, but the description adds meaningful context: it must explicitly label partial coverage and must not reinterpret linked-market reads as issuer truth or investment advice. This goes beyond the crude safety profile provided by annotations. The description also enumerates the exact categories of data returned, which clarifies the tool's behavior in terms of output composition.

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 moderately long but well-structured: it opens with the primary use case, lists return contents, then summarizes parameters, and ends with behavioral constraints. Each sentence has a distinct purpose, though the phrase 'read-only and idempotent with no destructive side effects' is partially redundant with the annotations. Overall, it is appropriately sized for a complex audit tool and front-loaded with action guidance.

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 is remarkably complete given the tool's complexity: it covers when to use, what will be returned (a comprehensive list), required and optional parameters, and critical behavioral constraints (labeling partial coverage, avoiding conversion to investment advice). With a full output schema and annotations providing safety hints, the description adds all essential context for an agent to select and invoke the tool confidently. Even without an output schema, the return list would be sufficient for basic understanding.

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 the baseline is 3, but the description adds semantic relationships not obvious from the schema: it lists explicit accepted values for product (AI10, Synthetic AI10 ETF, AI-PERP-INTX, Tech100, TEK-19DEC30-CDE), states that source-date filters override window_days, and explains that limit/offset paginate factor-history rows. These enrich the parameter understanding beyond individual schema 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 it is an audit tool for the Delta Signal Synthetic AI 10 ETF, with specific use cases: understanding factor drivers, raw audit evidence, and verifying a four-level ATLAS-7 verdict. It lists a detailed set of returned data, distinguishing it from sibling tools like deltasignal_synthetic_etf_pressure_state or general signal tools. The verb 'audit' and resource scope are explicit and specific.

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 explicit conditions for use ('when the user asks what factors drive...', 'asks for raw audit evidence', or 'asks whether the current pressure state is a full four-level ATLAS-7 verdict'). It does not explicitly name alternative tools or when-not-to-use cases, but the when-conditions are clear enough to guide an agent away from pressure-state or signal tools. The 'must not convert' sentence also sets usage boundaries by outlining that it does not produce investment advice or exchange-native truth.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations (readOnly, idempotent, non-destructive), the description adds valuable context: it is a 'composite tool' using persisted evidence, and explicitly lists non-behaviors (no live fetch, no trades, no recorder mutation). This goes well beyond the structured hints and informs the agent about limitations that are not otherwise visible.

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 compact (three sentences) and well-structured: trigger and output first, parameter overview second, behavioral caveats last. Every clause earns its place; no filler or redundancy.

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 a rich output schema present, the description need not explain return values, and it does not. It covers what the tool does, when to use it, key parameters, and behavioral boundaries, which is sufficient for an agent to select and invoke 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% so a baseline of 3 applies, but the description adds meaningful value by enumerating the accepted product values (including 'Tech100' and 'TEK-19DEC30-CDE' not in schema examples) and by explaining that date filters and limit/offset constrain the factor-history window. This contextual hand-holding raises it above baseline.

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 opens with a specific trigger ('when the user asks for the current pressure state of the Delta Signal Synthetic AI 10 ETF or Synthetic Tech100 ETF') and clearly names the resource and action. It distinguishes itself from siblings by focusing narrowly on the synthetic ETF pressure state and listing exact product identifiers, avoiding overlap with general pressure board or market context 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?

It explicitly states the usage context in the first sentence ('Use this read-only composite tool when...'), which is clear and actionable. It also provides exclusions ('does not fetch live exchange state, place trades, or mutate recorder state'), but does not name alternative tools for those cases, so it falls short of a full 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already set readOnlyHint, idempotentHint, and destructiveHint. The description adds concrete behavioral details beyond annotations: 'it performs one HTTPS read against the Natural Language route, has no destructive side effects, and never executes trades, wallets, settlements, or writes.' It also discloses that style changes tone/density only, not facts, and that the brief preserves ranks, stress values, quality flags, nulls, source dates, and caveats.

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 three sentences, front-loaded with purpose, then parameters, then behavior. Every sentence adds value with no redundancy or fluff, making it efficient and easy to parse for an agent.

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 covers purpose, parameter semantics, behavioral safety, and alternatives. An output schema exists, so return values need not be enumerated. The description is complete for an agent to select and invoke the tool correctly, with no apparent gaps 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 description coverage is 100%, and the description repeats the parameter semantics without adding new information beyond the schema. It restates limit range, offset pagination, and style options, all already documented in the schema. The baseline of 3 applies because the schema carries the parameter documentation burden.

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 explicitly states the tool converts the Top Stressed screen into human-readable Markdown, with a specific verb ('explained') and resource ('Top Stressed screen'). It also distinguishes itself from the sibling raw deltasignal_top_stressed by contrasting it as premium vs. cheap structured JSON.

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 when-to-use guidance: 'when the user wants the Top Stressed screen explained in human-readable Markdown.' It names the alternative tool and when to use it: 'Use raw deltasignal_top_stressed for cheap structured JSON and this tool for premium human-facing summaries.' It also provides parameter usage guidance for limit and offset.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.