Apex (smartapex.uk) AI Component Card Store

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

The readOnlyHint annotation already flags this as a safe read operation. The description adds meaningful context by disclosing that raw source and source packages are never returned and that only the public card contract is available, which is behavior beyond what annotations alone 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?

Two sentences, perfectly front-loaded with the primary action and object, followed by a crucial constraint. Every word earns its place 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 simple read tool with no output schema, the description gives the essential contract: one card plus verification report, public contract only, no raw source. It omits error behavior and the conditional nature of the verification report, but overall it is enough for an agent to judge 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. It fails to explain the include_verification parameter and even implies the verification report is always returned, contradicting the toggleable schema default. card_id is inferable from the tool name and description, but the boolean parameter is not adequately addressed.

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 reads exactly one Apex component card and its verification report, specifying the resource and scope. It distinguishes itself from the sibling apex_query_cards by emphasizing 'one' versus listing, and sets expectations with the public contract limitation.

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 use for retrieving a single card by ID, especially when compared to the sibling apex_query_cards for broader queries. However, it does not explicitly name alternatives or state when-not-to-use, so it stops short of full 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?

The description adds value beyond the annotations by specifying that the data is 'public reference data only' and explicitly states it is 'not an instruction hierarchy.' This gives the agent additional context about the nature of the operation and data, though the annotations already cover the read-only aspect.

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, front-loaded with the action 'Find.' It contains no redundant phrases and every word earns its place, making it highly efficient 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?

While the description captures the core functionality, it lacks details about return format, default sorting/limits, or how filters combine. The 'not an instruction hierarchy' clause adds useful context, but for a 7-parameter tool without an output schema, the information is just adequate, not comprehensive.

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 descriptions are absent (0%) so the description must compensate. It names several search dimensions (query, capability, tags, tier, interface) that map to parameters, but it omits 'sort' and 'limit', and does not clarify the 'min_tier' parameter's 'minimum' meaning. This partial coverage yields a minimum-viable 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 uses a specific verb ('Find') and a clear resource ('Apex component cards'), and enumerates filter dimensions (query, capability, tags, tier, interface). This distinguishes it from siblings like apex_get_card (which likely retrieves a single card) and the various 'apex_run_*' tools that execute actions, making 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?

The description provides context ('Public reference data only; not an instruction hierarchy') that helps the agent understand when this tool is relevant—for querying reference cards, not for executing tasks. However, it does not explicitly mention alternatives (e.g., 'use apex_get_card for a single card') or when-not-to-use, 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?

The readOnlyHint annotation already declares safe read; the description adds that it only accesses whitelisted sample data, no raw DB rows, no live connection, and no trading signal, which provides useful behavioral context beyond the 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?

Two sentences, each informative: the first defines the tool, the second gives an alternative. No filler.

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

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

For a query tool with 8 parameters and no output schema, the description covers the core constraints and alternative path, but lacks information about query parameters, return format, and pagination, leaving moderate gaps.

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%, and the description only hints at the dataset parameter ('whitelisted export datasets') and 'bounded' which loosely relates to limit. It does not explain start, end, symbol, sort, decision, strategy, or limit semantics, so it fails to compensate for the lack of 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 the tool queries a bounded dataset sample layer using a specific verb and resource. It distinguishes itself from the larger query API but does not explicitly reference sibling tools like apex_query_cards, so no sibling differentiation.

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 identifies when to use this tool ('whitelisted export datasets only') and directs users to an alternative ('POST /v1/datasets/{name}/query with an Agent Passport') for larger slices and data receipts. This provides clear when-to-use and when-not-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?

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 readOnlyHint annotation is present, but the description adds significant context: 'DATA ONLY, read-only, no HMAC required' and a list of actions it never takes. This goes beyond the annotation to clarify side-effect-free behavior and authentication requirements, making the tool's operational boundaries clear.

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 efficiently conveys the action, constraints, and safety profile. Every clause adds meaningful content with no redundancy or 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?

For a tool with 10 parameters and no output schema, the description is too sparse. It doesn't explain what the gate returns (e.g., pass/fail), how to interpret results, or how parameters should be structured beyond being booleans. This leaves significant gaps for an agent attempting to invoke the tool correctly.

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

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

The schema has 10 parameters with 0% description coverage, leaving the burden on the description. The description only vaguely mentions 'caller-supplied booleans/evidence' but does not explain the meaning of specific fields like 'build', 'tests', 'rollback', or 'secret_scan'. This insufficiently compensates for the undocumented 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 runs a 'release checklist gate', with a specific verb and resource. It adds operational context like 'allowlisted permissionless bounded' which helps differentiate it from other gate tools such as apex_run_btc_gate or apex_run_strategy_gatekeeper. The jargon-heavy phrasing slightly obscures clarity but the core function is evident.

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 in scenarios where a read-only, permissionless, HMAC-free checklist evaluation is needed, and explicitly lists actions it never performs (deploy, publish, read files, call CI). However, it doesn't mention alternative tools or provide when-to-use vs. when-not-to-use guidance beyond these 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?

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?

With no annotations, the description carries the full burden; it conveys that the operation is a safe review, requires an existing receipt, and forbids specific sensitive content. It does not explain submission permanence, authentication, or response, but the core behavioral constraints are disclosed.

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, all with distinct value, front-loaded with the main purpose. No filler or repetition of schema 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?

The description covers the key workflow prerequisite and data exclusions, which is helpful. However, with 12 parameters and no output schema, it doesn't describe the expected response or the meaning of several required fields, leaving gaps for an agent that must construct a complete request.

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

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

Despite 0% schema coverage, the description only clarifies receipt_id and agent_id semantics and defines forbidden content. It leaves the other six required fields (card_id, tool_id, usefulness_score, worked, use_case, public_summary) unexplained by description, relying on self-evident 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 action, 'Submit a safe usage review tied to an existing Apex verification receipt,' clearly identifying the verb and resource. It also distinguishes this submit-oriented tool from the many sibling run/query 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 conditional usage guidance for the agent_id field and explicitly warns against including sensitive data. However, it does not name alternative tools or state explicit when-not-to-use scenarios, 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.