Apex (smartapex.uk) AI Component Card Store

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

Annotations already declare readOnlyHint: true, but the description adds valuable context beyond that by stating that raw source and source packages are never returned. This tells the agent what the response will not contain, which is not covered by the annotation. This is a meaningful behavioral disclosure, earning a 4.

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 with no filler, front-loaded with the core action and a clear exclusion. Every word earns its place, and the structure is excellent.

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 operation with a readOnlyHint annotation, the description covers what it does and what it excludes. It does not discuss error conditions or return format, but those are minor for a tool this straightforward. The context is sufficient for an agent to call it correctly, so a 4 is appropriate.

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 0%, so the description must compensate. The description mentions 'verification report', which maps to the 'include_verification' parameter, but it does not explicitly state that the parameter controls whether the report is included. It also does not elaborate on 'card_id' beyond its obvious purpose. The description adds some value but could be more explicit, so a 3 is fair.

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 ('Read'), a specific resource ('one Target5 tool card'), and what it returns ('plus its verification report'). It also explicitly clarifies what it does NOT return ('raw source and source packages are never returned'), which distinguishes it from potential alternatives. This is clear and unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use for fetching a single card by ID, but it does not explicitly state when to use this tool versus siblings like 'apex_query_cards' (which likely lists cards) or provide exclusions. There is no 'use this when...' or 'for listing, use X instead' guidance. It provides context but not explicit routing, so a score of 3 is appropriate.

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=true and openWorldHint=false. The description adds that this is public reference data and not an instruction hierarchy, providing useful scope. However, it does not describe result shape, pagination, default sort, or filter combination behavior, so the added behavioral detail remains thin.

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 one tight sentence plus a short clarifying clause. It front-loads the core purpose and adds the key data-scope caveat without 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?

For a tool with seven parameters and no output schema, the description is adequate for orienting an agent but not complete. It lacks expected defaults, sort behavior, how filters interact, and any hint about what a returned card contains. The read-only annotation covers safety, but invocation details are still underspecified.

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 0%, so the description must compensate for seven undocumented parameters. It maps five of them (query, capability, tags, tier, interface) to meaningful filter dimensions, but it does not clarify q semantics, sort meaning, limit defaults, or how multiple filters combine. The bare parameter names in the schema do some work, but the compensation is only partial.

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 ('Find'), names the resource ('Target5 tool cards'), and lists searchable facets (query, capability, tags, tier, interface). It implies a search/filter behavior distinct from a direct fetch like apex_get_card, but it does not explicitly contrast itself with any sibling tool, so it misses the top score.

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 usage when an agent needs to locate Target5 tool cards via filters. 'Public reference data only; not an instruction hierarchy' gives contextual boundaries, but it does not name alternatives or state when to prefer this over apex_get_card or other query 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=true and openWorldHint=false, so the description's safety profile is covered. The description adds useful context such as 'no raw DB rows, no live DB connection, no trading signal' which clarifies the data scope but does not explain response format or other behavioral nuances, like whether results are capped at 100. It does not contradict annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, concise and front-loaded with the core purpose. The second sentence adds critical usage guidance on limitations and alternatives. No wasted words, but could be slightly more compact without losing essential information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is moderately complex with 8 parameters, some enums, and no output schema. The description covers the data scope and alternatives but does not clarify parameter roles, expected return format, or pagination/limits, which could be inferred from schema defaults. Given the tool's complexity and lack of output schema, the description is adequate but not fully complete; more detail on parameters and return behavior would be useful.

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 0%, so the description should compensate for parameter meaning, but it only mentions that it queries a 'sample layer' and 'whitelisted export datasets', without describing any of the 8 parameters. The schema's enum for 'dataset' and patterns for dates provide some implicit meaning, but the description adds minimal value. Since the description does not explain parameters, a baseline of 3 is appropriate, but it falls short of fully compensating.

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 queries a free bounded stillme dataset sample layer with specific verbs and resource ('Query the free bounded stillme dataset sample layer'). It also distinguishes itself from potential alternatives by naming the POST endpoint for larger slices. This makes its purpose unmistakable even among numerous 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 gives explicit context on when to use this tool: for whitelisted export datasets, and explicitly notes it is not for raw DB rows, live DB connections, or trading signals, which helps rule out misuse. It also directs to an alternative (POST /v1/datasets/{name}/query) for larger slices, but does not clearly list when to use sibling tools, so not 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 readOnlyHint=true and openWorldHint=false, but the description adds valuable context: 'DATA ONLY, read-only, no HMAC required; no route discovery, source reads, or network access.' This clarifies permissionless operation and constraints 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 a single, front-loaded sentence that packs all essential information without fluff. Every word adds value: scope, safety, permissions, and explicit exclusions.

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 two-parameter read-only diff tool, the description covers purpose, safety, and constraints. There is no output schema, but the description's mention of 'DATA ONLY' and 'diff' implies a data-returning operation. It lacks explicit return format details, but the tool's simplicity keeps this from being a major gap.

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 0%, so the description must compensate. It identifies 'before' and 'after' as endpoint lists, giving meaning to both parameters. However, it does not specify the structure of list items or the expected format for endpoints, leaving some ambiguity for a zero-coverage 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's purpose: running an API contract diff over supplied before/after endpoint lists. The verb 'Run' and resource 'API contract diff' are specific, and it is distinct from sibling tools like apex_run_agent_secret_scanner or apex_run_agent_dockerfile_lint.

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 context on when to use this tool (for diffing supplied endpoint lists) and explicitly excludes other activities (no route discovery, source reads, or network access). It does not name alternative tools, but the name and scope strongly differentiate it from 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?

The description adds behavioral context beyond the readOnlyHint annotation by stating it will not echo raw values and explicitly mentions operational traits: 'DATA ONLY', 'no HMAC required, no network access'. This provides valuable information about data handling and side-effect-free operation, which aligns with the annotations without contradiction.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two short, information-dense sentences. The first defines the action and outputs without unnecessary words; the second lists key constraints. Every phrase adds value, making it exceptionally concise and well-structured.

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 simplicity (one parameter, no output schema) and the presence of readOnlyHint, the description covers the essential context: purpose, behavior, constraints, and enough detail about expected output via the listed profiling aspects. It does not explain return format details, but since no output schema is provided, the natural-language list of what is profiled is sufficient for an agent to anticipate the result.

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 0% schema description coverage, the description must compensate. It calls the parameter 'supplied tabular rows', which clarifies that the array of objects represents a table with rows, but it does not detail the expected shape of each object or constraints beyond what the schema already provides (min/max items). It adds some meaning but not enough to fully bridge the coverage gap.

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 verb 'Profile' and the resource 'supplied tabular rows', listing specific outputs (shape, nulls, types, numeric ranges, sensitive-name hints). It also distinguishes itself from sibling tools by emphasizing 'without echoing raw values' and 'DATA ONLY', making its scope distinct from other data analysis tools like apex_run_empyrical_metrics or apex_run_alphalens_factor_research.

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 usage for profiling tabular data but does not explicitly state when to use this tool vs alternatives. It mentions constraints like 'no HMAC required, no network access' but provides no direct comparison or exclusion of other sibling tools, only an implied context.

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 readOnlyHint annotation, the description discloses 'DATA ONLY, read-only, no HMAC required; no build, no registry lookups, no network access,' adding concrete operational constraints not present in the annotations. It also lists the specific lint checks, giving insight into the tool's behavior. It does not describe output format, but the annotations already cover safety, so the added context is valuable and consistent.

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 tight two-sentence structure: the first declares the action and lists checks, the second summarizes operational constraints. Every phrase contributes, with no redundancy or filler. The information is front-loaded: the main purpose appears immediately.

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 one parameter and no output schema, the description covers purpose, scope of checks, and operational constraints (read-only, no network access). It does not explicitly describe the return value, but the listed lint categories imply the nature of findings. Given the tool's simplicity and the presence of annotations, the description is sufficiently complete 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?

The input schema provides only the parameter name 'dockerfile' with no description (0% coverage), so the description must clarify semantics. It does so by referring to 'supplied Dockerfile text,' indicating the parameter is the raw content as a string, not a file path. This meaningfully supplements the schema, though it could be more explicit about expected formatting (e.g., plain text vs. base64).

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 performs 'static best-practice lint over supplied Dockerfile text' and enumerates specific check categories (e.g., unpinned bases, curl-pipe-shell), making the purpose unmistakable. It distinguishes the tool from sibling functions like secret scanner or data profile by focusing on Dockerfile-specific linting.

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 tool is for linting Dockerfile content, but does not explicitly state when to use it over alternatives or mention exclusions. For example, it checks 'baked-in secrets,' which overlaps with the sibling apex_run_agent_secret_scanner, yet no guidance is given on choosing between them. Usage is inferred rather than prescribed.

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 annotation readOnlyHint=true is reinforced and significantly expanded: 'DATA ONLY, read-only, no HMAC required; embedded policy table only, no registry lookups or network access.' This tells the agent exactly what side effects are absent and what internal resources are used, exceeding the annotation's basic safety signal.

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 tight sentences, each adding distinct value: function, safety/constraints, and purpose/caveat. No filler or repetition, front-loaded with the main verb. Exemplary conciseness.

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 tool with no output schema and moderate parameter count, the description gives a strong overall picture: what it does, when to use, and safety profile. However, the parameter ambiguity and lack of output shape prevent a perfect score, as an agent would still need to infer how to structure the licenses and dependencies inputs.

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 0% and the description provides minimal compensation. It references 'supplied dependency licenses' and 'embedded policy table', which loosely maps to the licenses and policy parameters, but it does not explain the dependencies object, the relationship between licenses and dependencies, or the expected format of policy. Hard to invoke correctly without more guidance.

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 action ('Classify supplied dependency licenses') and clearly defines the three buckets (PASS/REVIEW/BLOCK), distinguishing it from sibling tools like release readiness gates or API contract diffs. It also uses SPDX-style identifiers, giving precise scope.

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 states this is 'a release gate' and clarifies it is 'DATA ONLY, read-only, no HMAC required', implying safe usage in CI/CD pipelines. It does not name explicit alternatives but the 'not legal advice' caveat sets expectations. Lacks a direct when-not-to-use vs sibling comparison.

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 meaningful behavioral guarantees beyond the readOnlyHint annotation: 'secret values never leave the redactor', 'no HMAC required', and 'no network access'. These details help the agent understand safety and side-effect boundaries.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single well-structured sentence that leads with the main action, describes outputs, and appends key safety constraints. Every clause provides value with no 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?

The description covers the purpose, output contents, and important behavioral constraints, but it leaves the `text` parameter entirely undocumented. With no output schema, more detail on the return structure would make it fully complete for an agent to 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 has 0% description coverage, yet the description only references 'logs' implicitly, never explaining the `text` parameter. It does not add meaning beyond the parameter names, so the agent cannot distinguish between the two params or know how to use 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 states a specific verb ('Redact and summarize') and resource ('supplied logs'), and names the outputs: severity, repeated failure patterns, and short safe samples. This clearly distinguishes it from sibling tools like secret_scanner or data_profile.

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 tool should be used when logs need redaction and summarization, but it does not explicitly say when to use it over alternatives or provide exclusions. The guidance is implied rather than direct.

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 goes beyond the readOnlyHint annotation by disclosing that no verification or publication authorization occurs, and that the tool trusts caller-supplied declarations. This is important context because the word 'gate' might imply enforcement; the description directly clarifies that this tool only aggregates.

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, front-loaded with the action and output, followed by a single limitation sentence. No filler or redundant restatement of the tool name.

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 complete enough for a read-only aggregation tool: it specifies what it accepts, what it returns at a high level (PASS/WATCH/BLOCK), and what it does not do. A minor gap is the lack of detail about the exact output shape or how the aggregation threshold works, but that is not critical for invoking 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 parameters are already documented in the schema. The description adds general context about boolean declarations but does not explain individual parameter semantics or aggregation rules, which is acceptable given the baseline for fully covered schemas.

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 precise verb and object: it aggregates caller-supplied boolean release-check declarations into PASS/WATCH/BLOCK. It also explicitly contrasts itself with running CI, inspecting files, verifying declarations, and authorizing publication, which clearly differentiates it from sibling run_* 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 implies when to use it: when you only need to aggregate declared booleans into a gate result, not when you need actual verification or authorization. The negative list ('Does not run CI, inspect files, verify the declarations, or authorize publication') provides explicit when-not guidance, though it does not name alternative 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=true, but the description adds significant behavioral transparency beyond that: it promises redacted findings, hashes, and line numbers only, never raw secret values. This directly addresses a critical concern—secret leakage—and explicitly states the tool will not expose sensitive data. It also clarifies 'no HMAC required', which is a meaningful operational trait. There is 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 extremely concise: two sentences that front-load the action ('Run...') and immediately state key attributes (permissionless, bounded, DATA ONLY, read-only). Every clause adds value: safety, scope, and output format. 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?

Despite having no output schema, the description tells the agent exactly what to expect: redacted findings, hashes, line numbers, and never raw secret values. Input parameters are simple and optional, and the description covers the main input mode (text/file content). For a tool with this complexity, the description is sufficiently complete to invoke correctly and interpret results.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has two parameters (text, files) with zero textual description. The description mentions 'text/file content', which aligns with the parameter names and gives a basic hint of what they accept. However, it does not explain the structure of the 'files' array (name, path, text/content) or indicate whether both parameters can be used together or are mutually exclusive. The description adds some semantic value but does not fully compensate for the 0% schema coverage.

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 specific verb 'Run' and clearly identifies the resource: 'secret scanner'. It explicitly states the scope 'over supplied text/file content', which differentiates it from sibling run agents (e.g., data profiling, API contract diff). The purpose is unambiguous and immediately distinguishes this tool from all others.

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 usage context: it is 'allowlisted permissionless bounded', 'DATA ONLY, read-only, no HMAC required'. This tells the agent that this tool requires no special permissions or HMAC authentication, making it safe for low-risk scanning tasks. It does not explicitly name alternatives or when not to use it, but the strong context about permissions and data constraints gives practical guidance for selection.

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 goes beyond the readOnlyHint annotation by explicitly stating 'DATA ONLY, read-only, no HMAC required, no network, no orders, no wallet/account access.' It also discloses that it is a pure TypeScript reimplementation of selected alphalens-reloaded routines, providing 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?

Two sentences, front-loaded with the core purpose and followed by safety details. It is efficient, though the phrase 'allowlisted permissionless bounded' is slightly redundant with the later 'DATA ONLY, read-only' clarification.

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 tool has five parameters including nested records and an enum, and no output schema. The description does not explain parameter semantics, return values, or how the function enum selects behavior. It focuses on safety but omits functional details needed for correct invocation and result interpretation.

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 0% schema description coverage, the description carries the burden of explaining parameters. It mentions 'factor rows' but does not explain the expected structure of records, the meaning of period/options/quantile, or the behavior of the function enum. The enum values are self-explanatory to domain experts but not explicitly documented.

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 runs an 'alphalens-style factor research wrapper' over supplied factor rows, which is a specific verb+resource. It distinguishes itself from siblings by the unique 'alphalens-style' qualifier, though it does not explicitly name alternatives.

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 context that it is permissionless, bounded, and data-only, implying it is safe for read-only analysis without auth/network. However, it does not explicitly state when to use it over sibling research tools like empyrical_metrics or pyfolio_tearsheets, nor any 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?

Beyond the annotations' readOnlyHint, the description explicitly discloses constraints: 'no HMAC required, no broker adapters, no network, no orders, no wallet/account access.' It also notes it's a 'pure TS reimplementation of a narrow OSS backtrader subset,' providing detailed boundary context that annotations alone do not convey.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two dense, information-rich sentences. The first sentence states the action and inputs; the second wraps up constraints. Every word earns its place, with no 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 covers purpose, input types, safety, and implementation bounds, but it does not describe the return value or output format (no output schema). For a complex backtest engine, this is a small gap; overall, it provides sufficient context for selection and 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 coverage is 0%, so the description must compensate. It clarifies 'bars' and 'strategy' via 'OHLCV bars' and 'declarative strategy rules,' but 'costs' and 'initial_cash' are left ambiguous and not explained. The description adds partial meaning but does not fully compensate for the lack of schema documentation.

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 'Run' with a precise resource: 'allowlisted permissionless bounded backtrader-style single-asset backtest engine.' It clearly states the tool's function and distinguishes it from sibling apex_run_* tools by focusing on backtesting over OHLCV bars and declarative strategy rules.

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 implies when to use: to run a backtest on supplied data and strategy rules. It mentions 'DATA ONLY' and 'no broker adapters' to set expectations, but it does not explicitly name alternative tools or provide 'when not to use' guidance. The sibling list offers context, so the usage context is clear.

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 readOnlyHint is true, the description adds substantial behavioral detail: 'Pure calculation, DATA ONLY, read-only, no HMAC required, no orders, no wallet/account access' and 'Not trading advice'. It also discloses the return structure (ALLOW/BLOCK + move_pct), which is beyond the annotations. No contradiction exists.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three tight sentences with no filler. It front-loads the core purpose and then adds safety/disclaimers in a structured way. Every sentence 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?

For a pure calculation tool with no output schema, the description adequately covers the return value and safety profile. It lacks detail on default behavior when threshold_pct is omitted, but overall it is sufficient for an agent to invoke it correctly in most contexts.

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 0% schema description coverage, the description compensates by explaining the roles of current_price and reference_price ('current vs reference price') and threshold_pct ('drop threshold'). However, it does not specify that threshold_pct is optional or detail the exact calculation, leaving some semantic gaps.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function as an advisory market-regime gate that returns ALLOW or BLOCK plus move_pct based on current vs reference price and a drop threshold. It uses a specific verb ('returns'), names the resource ('BTC regime gate'), and implicitly distinguishes itself from sibling tools by emphasizing its advisory and calculation-only 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?

The description provides clear context for when to use the tool—when an advisory, pure-calculation gate is needed—and explicitly states exclusions ('no orders, no wallet/account access'). However, it does not name alternatives or explicitly say 'use this instead of X', 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?

Beyond the readOnlyHint and openWorldHint annotations, the description explicitly lists behavioral boundaries: 'no HMAC required, no source release, no orders, no wallet/account access.' This is rich, beyond-annotation disclosure of what the tool will not do, adding significant context 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 entire description is one front-loaded sentence that efficiently states the purpose and constraints. Every clause adds distinct information, with 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?

The description adequately covers safety and accessibility but falls short on explaining what the diagnostic computes, what the input represents, or what output to expect. Given the statistical nature of the tool and the absence of an output schema, this is a meaningful gap, making it minimally viable but not 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 description provides zero information about the parameters (returns, n_trials, confidence, trial_sharpe_variance) and the schema has no per-parameter descriptions. With schema description coverage at 0%, the description was expected to compensate but does not, leaving parameter meaning entirely to guesswork from 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 clearly states the action ('Run') and the specific resource ('deflated-sharpe diagnostic'), and the restrictive qualifiers ('allowlisted permissionless bounded') distinguish it from sibling run_* tools. The 'DATA ONLY, read-only' addition further clarifies scope.

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 usage for running a deflated-sharpe diagnostic without authentication or side effects, but it does not explicitly state when to choose this tool over alternatives or provide exclusion criteria. The access constraints ('no HMAC required', 'no orders') offer implicit guidance but no direct comparison to 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?

Beyond the readOnlyHint annotation, the description adds valuable behavioral context: it is pure calculation, data-only, requires no HMAC, places no orders, has no wallet/account access, and is not trading advice. These details go well beyond what annotations already convey and give the agent a clear safety profile.

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 concise sentences, front-loaded with the core purpose and return values, followed by safety/constraint details. There is no filler or repetition; 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?

For a simple pure-calculation tool with only two self-explanatory parameters and no output schema, the description is complete: it states the purpose, return values, input context, and all important safety/disclaimer caveats. The absence of an output schema is compensated by explicitly naming the return fields.

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 0%, so the description must compensate. The two parameters (consecutive_losses, recent_net_pnl) are self-explanatory and tied to the 'loss streak' context, but the description does not define their expected formats or bounds beyond the schema's min/max constraints. It adds some contextual meaning but not detailed parameter semantics.

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 advisory cooldown and size-penalty hints from a recent loss streak, listing exact return values (size_multiplier, cooldown_sec, severity). It distinguishes itself from sibling run_* tools by emphasizing that it is a pure, read-only, data-only calculation rather than an order or account operation.

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 usage after a recent loss streak and explicitly states read-only/no-order boundaries, but it does not provide explicit when-to-use/when-not-to-use guidance or name alternatives among the many sibling run_* tools. Context is clear but exclusions are only implied through safety constraints.

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 significantly expands on the annotations by noting 'DATA ONLY, read-only, no HMAC required, no network, no orders, no wallet/account access.' This adds crucial safety and scope details that align with readOnlyHint=true and openWorldHint=false. No contradiction exists.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is compact and efficient, front-loading the action and scope. Every sentence adds value—purpose, implementation fidelity, and safety. No redundancy or verbosity.

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 safety and high-level purpose well but lacks details about the output structure or parameter behavior. Since there is no output schema, the agent is left uncertain about what metrics are returned or how to interpret results. Adequate for a simple calculator but not fully 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?

With 0% schema description coverage, the description must compensate for parameter understanding. It only mentions 'returns' explicitly and leaves period, risk_free, and annualization unexplained. This forces the agent to infer semantics from the empyrical metric context, which may be insufficient.

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 'runs' an 'empyrical-style metrics calculator over supplied returns,' with a specific verb and resource. It distinguishes from sibling run tools by emphasizing metrics calculation on returns and the pure TS reimplementation of empyrical 0.5.5 conventions.

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 for when to use the tool: to compute bounded, permissionless empyrical metrics from returns, with no HMAC or network access. However, it doesn't explicitly list alternatives or state when not to use it, 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 readOnlyHint annotation, the description explicitly states 'no HMAC required, no orders, no wallet/account access' and 'Not financial advice,' adding valuable safety and operational context. It does not contradict 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 concise—three short sentences—front-loaded with the core purpose, and every word adds value. No redundant 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?

Without an output schema, the description should clarify what the tool returns (e.g., a fraction, a recommendation), but it only says 'advisory math.' It also omits explanation of optional parameters, leaving the tool incompletely specified for a 6-parameter function.

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 only mentions 'win rate and average win/loss facts,' which partially maps to the required params, but the optional params (regime, confidence, max_fraction) are not explained. With 0% schema description coverage, the description fails to fully compensate for parameter semantics.

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 computes 'fractional Kelly sizing math' from specific inputs, distinguishing it from sibling analytics tools. The verb 'sizing' and resource 'Kelly criterion' make the purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage context is implied (when you need Kelly sizing from win rate and average win/loss), but there is no explicit guidance on when to use this vs. alternatives, nor when not to use it. The 'DATA ONLY' note gives some constraint but not a full usage policy.

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 readOnlyHint annotation, the description discloses significant behavioral specifics: 'no HMAC required, no network, no orders, no wallet/account access' and that the output declares data_as_of 5.4.0. This goes well beyond the annotation and gives the agent confidence about side-effect-free, isolated execution. No contradiction with annotations; it reinforces them.

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 and every sentence earns its place: purpose, safety guarantees, and output version. It is front-loaded with the primary action, and there is zero fluff or repetition of schema fields.

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?

This is a simple tool with only 3 parameters and clear safety annotations. The description covers purpose, safety behavior, and a hint about output version. While there is no output schema and the exact return structure is not described, the tool is a well-known standard library wrapper, so the level of detail is sufficient for an agent to use it correctly. The only missing piece is a note about output shape or examples, but it's not critical for this simple use case.

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 0%, so the description must compensate for explaining the parameters. It only vaguely refers to 'calendar/date parameters', which adds no meaning beyond the parameter names and schema constraints. The enum for calendar and the date patterns are in the schema but the description does not clarify semantics like what values are valid or what each parameter controls.

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 'Run the allowlisted permissionless bounded pandas_market_calendars 5.4.0 calendar wrapper over supplied calendar/date parameters' with a specific verb (Run), resource (pandas_market_calendars), and parameters. It is distinct from sibling tools that focus on other tasks like agent reviews, data profiling, or trading strategies, so there is no ambiguity about what this tool does.

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 excellent context for when to use this tool: it is 'DATA ONLY, read-only, no HMAC required, no network, no orders, no wallet/account access' and is 'permissionless and bounded'. This clearly signals safe usage contexts. However, it does not explicitly name alternatives or state when NOT to use it, though the unique domain (market calendars) makes alternatives unlikely.

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 goes far beyond the readOnlyHint annotation by explicitly enumerating behavioral constraints: 'DATA ONLY, read-only, no HMAC required, no plots, no network, no orders, no wallet/account access.' It also notes the execution is 'allowlisted permissionless bounded', which reassures about side effects and resource limits. This adds substantial value over 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 a single dense sentence that front-loads the core purpose and then packs safety constraints. While every phrase carries information, the string of hyphenated qualifiers ('allowlisted permissionless bounded') and repeated negatives ('no network, no orders, no wallet/account access') makes it slightly less streamlined than optimal.

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 thoroughly covers safety and execution context, which is especially valuable given the annotation set. However, with no output schema, it omits what the tool returns (e.g., tear-sheet metrics, summary object) and any assumptions about input data (e.g., sorted dates), leaving some ambiguity for the agent about expected results.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate for parameter meaning, but it only says 'dated returns'—which mostly repeats the parameter name. It does not clarify the expected scale (decimal vs percentage), the need for chronological ordering, or the meaning of the fixed 'periods_per_year' const, leaving the agent to rely solely on schema 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 names a specific verb ('Run') and a specific resource ('pyfolio-reloaded 0.9.9 tear-sheet core') over 'dated returns', which clearly distinguishes it from sibling tools like apex_run_empyrical_metrics or apex_run_alphalens_factor_research. The qualifiers 'data only' and 'no plots' further disambiguate its scope.

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 when to use the tool—when you need a pyfolio tear-sheet over returns—and its constraints (permissionless, bounded, no network) suggest safe usage. However, it does not explicitly state when not to use it or name alternatives, leaving the agent to infer usage from the tool name and limited context.

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 readOnlyHint annotation, the description explicitly discloses access limitations (no HMAC, no network, no orders, no wallet/account access) and labels itself as 'DATA ONLY' and 'pure'. This provides exceptional additional context about the tool's operational scope.

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 tight sentences front-load the purpose and safety guarantees without redundancy. Every clause adds value, and the structure is ideal for quick parsing.

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 core purpose, output, and safety, but the missing meaning of `lower`/`upper` and any guidance on defaults/constraints leaves the tool incomplete for optional parameter use. With no output schema and 0% parameter coverage, the description is only partially sufficient.

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 only references 'prices'; the optional `lower` and `upper` parameters are left unexplained, and since schema description coverage is 0%, agents have no semantic grounding for them. The likely role as Hurst thresholds is not conveyed, making this a significant gap.

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 (classifies) and resource (supplied prices), clearly defines the output (Hurst estimate and regime label), and is well-distinguished from sibling tools by emphasizing 'pure regime classifier' and its data-only 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?

It clearly establishes the tool's context as a data-only, read-only classifier for prices, guiding agents to use it for regime analysis without side effects. However, it does not explicitly name alternative tools or when not to use it, stopping 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 readOnlyHint and openWorldHint annotations, the description adds critical behavioral details: malformed tags return a teaching error rather than crashing, it is a TypeScript port of a specific reference implementation, and it explicitly states no HMAC, no network, no orders, and no wallet/account access. These disclosures go well beyond the annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is compact—three sentences that cover purpose, example, provenance, error behavior, and safety traits. Each sentence adds unique information with no 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?

For a single-parameter sorting utility with no output schema, the description is complete: it specifies input, ordering, error behavior, and safety. The absence of an explicit return description is acceptable because the output is intuitively the sorted list, and the annotations already cover read-only semantics.

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 defines a single 'tags' array parameter, and the description adds meaning by showing accepted formats ('v1.9.0' or '1.9.0') and indicating that malformed input is handled gracefully. While it does not enumerate constraints like maxLength or maxItems, the examples and error behavior give the agent enough context to invoke the tool correctly.

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 action ('Sort supplied version tags') with a specific ordering ('NUMERIC version order') and a concrete example distinguishing it from lexical sorting. It differentiates this tool from siblings by focusing on semver sorting, a unique function among the apex_run_* family.

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 when to use the tool—whenever version tags need numeric ordering—and provides an example that clarifies the expected input. However, it never explicitly states alternatives or when not to use it, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true, and the description reinforces this with 'DATA ONLY, read-only'. It adds valuable context beyond the annotation by stating 'no HMAC required, no orders', explicitly ruling out authentication and trading actions. This transparency helps the agent understand the tool's safe, non-mutating nature without contradiction.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two concise sentences that front-load the core purpose and then list important safety constraints. Every word earns its place; there is no fluff or redundancy. The structure is clear and easy to parse.

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 11 parameters, 7 required, no output schema, and minimal annotations, the description must explain more about what the tool returns and how the gate works. It only lists input categories and safety guarantees, omitting the decision logic, output format, or how the 'composite' is computed. This is insufficient for a complex gate tool, leaving the agent with significant ambiguity.

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 0%, so the description must compensate for 11 parameters. It mentions conceptual inputs like 'CI lower bound', 'effect size', and 'slippage improvement', which roughly map to some parameters, but it does not define thresholds (metric_threshold), minimums (min_delta_sharpe, min_slippage_reduction_bps, min_sample_days), or settings like alpha and multiple_testing_mode. This leaves many parameters semantically unexplained.

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 'Composite advisory gate over supplied statistics' and lists the key inputs (CI lower bound, effect size, slippage improvement, sample depth, Holm/BH p-values). This conveys the tool's purpose as an evaluative gate, distinguishing it from simple single-statistic gates. However, it does not explicitly state the output behavior (e.g., pass/fail or advisory score), so it stops short of full clarity.

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 no explicit guidance on when to use this tool versus sibling gates like apex_run_deflated_sharpe or apex_run_dynamic_penalty. It implies use when you have all the listed statistics, but there is no mention of alternatives, prerequisites, or when not to use it. This lack of usage context leaves the agent to infer appropriateness.

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 readOnlyHint annotation, the description adds valuable behavioral context: 'no HMAC required, no orders, no wallet/account access' and 'Not trading advice.' This reassures the agent about side effects and trust level without conflicting 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 two sentences, front-loaded with purpose and outputs, followed by safety context. Every word earns its place, no 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?

There is no output schema, but the description states the two possible outputs (HOLD or EXIT_TIMEOUT). It covers the core logic and safety. However, it omits the role of optional parameters and the exact exit-condition thresholds, leaving some gaps for a complete 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 description coverage is 0%, so the description must compensate. It names 'seconds_open' and 'max favorable excursion' (mfe_bps) as inputs, but does not explain the optional timeout_sec and mfe_threshold_bps parameters, their units, or how they affect the calculation. This adds minimal meaning beyond the schema property 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 clearly states the tool's function: 'Advisory exit check for stagnant positions: returns HOLD or EXIT_TIMEOUT from seconds_open and max favorable excursion.' It uses a specific verb (returns) and names the resource (stagnant positions) and outputs, distinguishing it from sibling run 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 implies usage for stagnant positions ('Advisory exit check for stagnant positions') and clarifies safe read-only use ('Pure calculation, DATA ONLY, read-only, no HMAC required, no orders, no wallet/account access'). However, it does not explicitly mention alternatives or exclusions, 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?

No annotations are provided, so the description carries the full burden. It discloses authentication requirements (signed Agent Passport headers, agent_id alone is not authentication), signing requirements (full JSON-RPC body and POST /mcp path), and data exclusion rules (never include secrets, raw input/output, etc.). It does not explicitly state that this is a write/mutation operation, but 'Submit' implies it; the disclosure of auth and data-handling behavior is substantial.

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 dense paragraph that front-loads the core purpose and then provides critical authentication and data-handling guidance. Every sentence earns its place, though the length is somewhat high due to the detailed auth instructions. It is structured logically: purpose, receipt types, auth requirements, signing, and exclusions.

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 (12 params, no output schema, no annotations), the description covers the most critical operational context: receipt types, authentication, signing, and data exclusion. It does not explain return values or error cases, but the absence of an output schema lowers the burden. The description is complete enough for an agent to invoke the tool correctly in most cases.

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 0%, so the description must compensate. It mentions 'receipt' and 'review intent' but does not explain individual parameters like card_id, tool_id, usefulness_score, worked, use_case, or public_summary. The description adds context about the receipt requirement and authentication, but leaves parameter semantics mostly to the schema's names and constraints. With 12 parameters and 0% coverage, a 3 is appropriate but not higher.

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 ('Submit') and resource ('safe usage review tied to an existing Apex verification receipt'), and distinguishes it from the many sibling tools by focusing on review submission rather than analysis or query operations. It clearly identifies the two receipt types and their authentication requirements, making the tool's purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly explains when to use this tool: for submitting a safe usage review tied to an existing receipt. It also provides critical usage guidance by distinguishing permissionless bounded receipts (need only the receipt) from verified receipts (require signed Agent Passport request headers), and warns against including sensitive data. This is strong when-to-use and how-to-use guidance.

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