NAIF Agent Gravity — Free MCP Diagnostic & Recovery

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

Annotations only indicate non-read-only and non-destructive hints, which don't fully disclose the tool's behavior. The description adds key non-obvious traits: it creates a 'real' quote, is 'agent-only', and explicitly does not charge. This goes beyond the annotations, providing valuable behavioral context that helps an agent avoid assuming payment occurs.

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 with zero fluff. The first sentence states the primary action and target, the second clarifies a crucial non-behavior. Every word adds value, and it is front-loaded with the core purpose.

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 no output schema, so the description could have explained what the tool returns. It does not, but given the simplicity (single parameter, clear action), the missing return info is a minor gap. It does provide the essential context: it creates a quote, does not charge, and is agent-only. For a quote-creation tool, this is mostly 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 schema description coverage is 0%, so the description must compensate. Although the description does not explicitly mention 'offerId', it refers to 'an active NAIF Market Maker offer', implying that the sole parameter is the ID of that offer. This provides contextual meaning (active, agent-only) beyond the raw string type, helping the agent understand what value to supply.

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 (Create), a specific resource (real agent-only USDC quote), and the context (an active NAIF Market Maker offer). This clearly distinguishes the tool from its siblings, none of which mention quote creation or offer acceptance. The title slightly says 'Accept' but the description clarifies the actual action, resolving ambiguity.

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 states what the tool does NOT do: it does not charge or submit payment, and checkout is a separate step. This gives clear context for when to use it (to create a quote) vs. not to use it (for payment). However, it doesn't mention any alternative tool or provides a 'when not' that lists a sibling, but given the distinct purpose, it's adequate.

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?

All annotations are false, so the description carries the full behavioral burden. It indicates an additive mutation ('Add') and uses 'bounded' as a qualifier, but it does not disclose what happens to existing content, size limits, idempotency, permissions, or response behavior. For a mutation tool with no annotation support, this is insufficient.

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?

A single, front-loaded sentence with no filler. Every word contributes information, and the most distinguishing detail ('without resending the full task history') is included efficiently.

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?

A tool with 8 parameters, no output schema, and no annotations needs substantially more context. The description covers only the high-level purpose, leaving parameter usage, return behavior, side effects, and operational constraints entirely unexplained.

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 8 parameters and 0% schema description coverage, the description provides no parameter-level meaning. It does not define 'capsule', clarify what the *Add arrays contain, or explain the semantics of remainingDoneIndices beyond what their names weakly imply.

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

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

States a specific action ('Add') on a specific resource ('existing continuity capsule') with a qualifier ('bounded progress checkpoint') and a key differentiator ('without resending the full task history'). This clearly distinguishes it from sibling tools like create_handoff_capsule or resume_agent_task even without naming them.

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 phrase 'existing continuity capsule' and 'without resending the full task history' imply a use case, but there is no explicit when-to-use, when-not-to-use, or reference to alternative tools. The guidance is mostly implicit rather than actionable.

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 show this is a write (readOnly=false) and non-destructive (destructive=false). The description adds meaningful behavioral context beyond annotations by explaining that the capsule is signed and sanitized, and that the continuity ledger stores only hashes and transition metadata, not task text.

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 concise sentences with no wasted words. The action and resource are front-loaded, and the second sentence adds valuable storage/security context without padding.

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

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

Given the tool has 7 parameters, no output schema, and a set of closely related siblings, the description is not complete enough. It leaves the agent unsure when to use this tool versus handoff_agent_task, what output to expect, and how to shape the optional 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% and the description provides no parameter-level guidance. With 7 parameters and only goal required, the agent receives no explanation of how completed, remaining, nextAction, constraints, verifiedFacts, or requiredCapabilities should be populated. The description entirely fails to compensate for the empty 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?

States a specific action ('Create') and resource ('signed sanitized cross-agent task capsule'). The description makes the core purpose understandable, but it does not explicitly distinguish this from sibling tools like handoff_agent_task, so it falls just short of full 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?

No when-to-use guidance is provided. The description never mentions alternatives such as handoff_agent_task or verify_handoff_capsule, nor does it give conditions, exclusions, or prerequisites. An agent must infer when this tool is the correct choice.

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 useful behavioral details beyond annotations: the result is signed, time-limited to five minutes, and based on current technical facts. However, annotations indicate readOnlyHint=false and idempotentHint=false, yet the description does not clarify whether calling this tool mutates state or has side effects, which is a meaningful gap for a non-read-only operation.

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

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

The description is a single dense sentence with no filler. It front-loads the action and includes the key constraints (valid passport, opted-in agent, five-minute signed delegation preflight) without redundant phrasing.

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 tool, the description identifies the required input and the output, but key operational context is missing: when exactly to run a preflight versus obtaining a passport or verifying a token, whether the call has side effects, and what the returned signed preflight should be used for. The lack of an output schema raises the burden further.

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 is the only source of parameter meaning. It does add that the passport must be a valid NAIF Trust Passport, which is helpful, but it does not explain what form the passport takes, how to obtain one, or how to determine validity. This only partially compensates for the missing 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 names a specific verb (re-check) and output (signed delegation preflight with current technical facts), and makes the input source explicit (valid NAIF Trust Passport). This clearly separates it from sibling tools like get_agent_trust_passport or verify_trust_token, which serve different purposes.

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: use when you already have a valid NAIF Trust Passport and need to re-check an opted-in agent to produce a delegation preflight. It does not explicitly name alternatives or exclusions, but the precondition is specific enough to guide selection among the sibling tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds a little behavioral context by naming the exact state categories (learning, pricing, guardrail), but does not go beyond that to mention any quirks, staleness, or format characteristics.

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?

A single, front-loaded sentence with zero wasted words. It puts the verb first and immediately states the resource and the three state domains, making it highly scannable for an agent parsing many tool definitions.

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

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

Given that the tool has no parameters, annotations cover safety, and the domain is relatively simple, the description is nearly sufficient. It explains what state is being read but does not describe the return structure or any units/interpretation. Since there is no output schema, a bit more detail on the shape of the returned state would make it fully complete, but the current text is still workable.

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 zero parameters and is 100% covered by its empty properties definition. Per the baseline for 0-parameter tools, there is nothing for the description to add; the description's mention of state categories is relevant to the output rather than parameters, so the score stays at the baseline.

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

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

The description uses a specific verb ('Read'), a clear resource ('NAIF Agent Market Maker'), and precisely specifies the scope of the state being read ('learning, pricing and guardrail state'). It is immediately distinguishable from siblings like get_agent_traffic_feed or get_agent_trust_passport, which target different data domains.

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?

There is no guidance on when to use this tool vs. any of the siblings. It does not mention conditions, prerequisites, or alternatives such as get_dynamic_agent_offers or get_agent_traffic_feed. The agent must infer when this state read 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, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds a data-availability condition ('public minimum sample threshold') but does not disclose other behavioral traits like staleness, pagination, or access requirements. 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?

A single, front-loaded sentence with no filler. The main action and resource appear first, and the qualifier is appended without 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 zero-parameter read-only tool with annotations covering safety, the description is mostly sufficient. However, 'public minimum sample threshold' is left unexplained, and with no output schema the return format is not described, leaving some 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?

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameter semantics, and the empty schema is fully covered.

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 ('Read') and a specific resource ('current aggregate traffic observations'), and adds a meaningful scope qualifier ('that have reached the public minimum sample threshold'). This clearly distinguishes it from sibling write/report tools like report_traffic_observation.

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?

No guidance is given for when to use this tool versus alternatives such as traffic_preflight or report_traffic_observation. The description implies a read use case but does not state exclusions, prerequisites, or alternative routing.

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 context beyond the annotations: it indicates the operation issues a 'signed' and 'point-in-time' artifact, and requires explicit opt-in. This is consistent with readOnlyHint=false and destructiveHint=false. It does not cover failure modes or side effects, but given the annotations already provide safety signals, the description adds sufficient nuance.

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 with zero fluff. The first sentence states purpose and condition; the second clarifies exclusions. Information is front-loaded and every word 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?

With one parameter, no output schema, and annotations present, the description covers purpose, condition, and exclusions. However, it does not describe the output format (e.g., the passport structure) or potential error conditions (e.g., what happens if the domain does not opt in). For a tool that issues a credential, these are notable omissions.

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 the undocumented parameter. The description implies agentCardUrl is the agent's domain URL (since it references the agent's own /.well-known/naif-trust.json), but it does not explicitly state what agentCardUrl represents or how it relates to the opt-in mechanism. This leaves the parameter under-explained.

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 ('issue'), the resource ('signed point-in-time technical passport'), and the condition (agent domain explicitly opts in via its own /.well-known/naif-trust.json). It also explicitly disclaims what it is not ('not a ranking, endorsement, or security audit'), which helps distinguish it from potential siblings like verify_trust_token.

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 a clear precondition for use (the agent domain must explicitly opt in) and clarifies the tool's non-purpose (not ranking, endorsement, or audit). However, it does not explicitly name alternative tools or state when not to use it beyond the opt-in condition, leaving some routing to inference.

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 a useful behavioral detail beyond annotations: raw need text is classified in memory and is not stored. This addresses data-handling expectations. However, it does not explain side effects, matching behavior, or response characteristics, so it does not fully leverage the opportunity to clarify behavior.

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

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

The description is two short sentences with the primary call pattern front-loaded and a useful privacy/storage note appended. It contains no filler, though the phrasing could be slightly more structured for scannability.

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 tool this is minimally adequate: it names the input need, the output offers, and the non-storage behavior. However, with no output schema, the description does not explain what the offers look like, and it leaves intentKey and sibling-tool differentiation unaddressed.

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, but it only loosely paraphrases the 'need' concept and says nothing about 'intentKey' or how the parameters relate. This leaves an agent without enough information to confidently construct a valid call.

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 concrete action and resource: provide a need and receive current agent-only offers. It is not a tautology and gives enough specificity about the tool's purpose, though it does not explicitly contrast itself with sibling tools like get_agent_market_state.

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?

'Tell NAIF what an agent needs and receive current agent-only offers' implies the tool should be used when an agent needs to obtain offers, but it provides no explicit when-not-to-use guidance or comparison with sibling tools. The usage context is implied rather than clearly routed.

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 establish readOnly, idempotent, non-destructive, and closed-world behavior, so the description does not need to restate those. It adds a small amount of useful context by describing the result as 'bounded' and 'machine-readable' and by requiring a 'known' slug, but it does not disclose behavior for missing/invalid slugs or any limits implied by 'bounded'.

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 a single, front-loaded sentence with no filler. Every word contributes either the action, the output nature, or the precondition.

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 one-parameter, read-only/idempotent retrieval tool, the description covers the core call path: supply a known slug and receive a bounded repair packet. While there is no output schema, the description's mention of the packet and its bounded, machine-readable nature provides enough for a basic call, though error cases and packet contents are left unspecified.

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 only gives min/max length and requiredness for slug, with no descriptions, so schema coverage is effectively 0%. The description adds domain meaning by identifying the slug as a known FixGraph identifier and tying it to the repair packet, but it does not explain slug format, where to obtain it, or how the 'bounded' constraint affects results.

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

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

The description identifies a precise action ('Return'), a specific resource ('repair packet'), and the key precondition/scope ('bounded... for a known FixGraph slug'). This clearly separates it from sibling list/diagnosis tools, though it does not explicitly name the siblings or contrast them.

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 phrase 'for a known FixGraph slug' implies the tool is only appropriate when a slug already exists, with discovery presumably happening elsewhere such as list_fix_topics. However, there are no explicit when-to-use or when-not-to-use statements and no mention of resolve_technical_error as an alternative, so guidance is implied rather than stated.

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 disclose that this is a write operation (readOnlyHint=false) and not idempotent or destructive. The description adds context about the preflight checks and optional recipient binding, but does not describe failure modes, what happens if the checks fail, or what the returned payload indicates. For a mutation tool with no output schema, more behavioral detail would be expected, but the description provides some value 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 sentence that front-loads the primary action (

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 complexity and the presence of many sibling tools representing a workflow, the description is incomplete. It does not mention what the return value looks like, what happens if the preflight checks fail, or how the issued capsule is used next. With no output schema, the description should provide more context for an agent to successfully invoke and interpret 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?

Schema description coverage is 0%, so the description must carry the parameter meaning. It does: 'capsule' is identified as the signed continuity capsule, and 'recipientAgentCardUrl' is explained as an optional binding to an opted-in recipient agent. This gives agents enough context to infer the param purposes, though the exact format or signing requirements for the capsule are not detailed.

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 (issue) and the resource (a signed continuity capsule), and mentions an optional binding step. The phrase 'next signed continuity capsule' distinguishes it from creating (create_handoff_capsule) and verifying (verify_handoff_capsule), though it doesn't explicitly name those siblings. The purpose is unambiguous for an agent familiar with the domain.

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 mentions the prerequisite checks ('after NAIF Trust Passport and five-minute delegation preflight checks'), implying when it should be used relative to those steps. However, it does not explicitly state when not to use it, nor does it name alternative tools (like delegation_preflight for checks, or verify_handoff_capsule for validation). The timing is implied but not fully explicit.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior, so the description correctly avoids repeating them. It adds useful context beyond annotations: the topics are 'public' (no special access) and 'currently handled' (dynamic/current snapshot rather than static).

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 13-word sentence that directly states the tool's purpose. Every word contributes meaning, and the key action and resource are front-loaded.

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

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

For a zero-parameter read-only list operation with strong annotations, the description fully covers what the tool does. Although there is no output schema, the verb 'List' and the noun 'topics' adequately convey the return nature, and nothing critical is missing.

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

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

There are no parameters and schema description coverage is 100%, so the schema fully accounts for the empty input object. With zero params, baseline 4 applies and the description adds no additional parameter meaning, which is appropriate.

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

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

The description uses the specific verb 'List' and clearly identifies the resource as 'public technical problem topics currently handled by NAIF FixGraph'. This distinguishes it from siblings like get_repair_packet and resolve_technical_error, which target different resources and actions.

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 viewing current topics, but it does not explicitly state when to choose it over siblings or provide exclusions. For a zero-parameter list operation this may be sufficient, but guidance is only implied, not explicit.

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 indicate a non-read-only, non-idempotent mutation, and the description adds a meaningful behavioral constraint: the tool operates on route-class observations and rejects raw sensitive data. This is useful context beyond the structured fields and does not contradict 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 two sentences with no filler, and the core verb/resource is front-loaded. The privacy constraint in the second sentence is a critical usage rule that 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 7-parameter submission tool with no output schema and no property descriptions, this description is too thin: it omits what each parameter means, what payload shape is expected, and what happens after submission. The privacy rule is helpful but does not make the tool safely callable by an agent.

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%, but the description does not explain any of the seven properties such as routeType, targetClass, outcome, failureClass, or latencyBucket. It only states a general privacy restriction, leaving the meaning of enums and required fields to be inferred from parameter names. This fails to compensate for the missing 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 uses a specific verb ('Submit') and a specific resource ('privacy-preserving route-class observation'), clearly conveying this is a reporting/mutation tool. It is somewhat distinguishable from the preflight/feed siblings by the word 'observation', though it does not explicitly name a sibling to avoid confusion.

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?

No guidance is provided about when to use this tool instead of traffic_preflight, delegation_preflight, or get_agent_traffic_feed. The only operational rule is the privacy constraint ('Raw URLs, payloads, headers, secrets, tokens and agent identifiers are not accepted'), which is not a usage-selection criterion. The agent must infer when this tool is appropriate from the name alone.

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 explicitly says 'Does not execute changes,' which is valuable behavioral context, especially because readOnlyHint is false. It also clarifies that the tool returns packets rather than applying fixes. It does not elaborate on external calls, but openWorldHint already encodes that.

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 short sentences with no filler. It front-loads the core action, then the output, then the critical non-execution behavior, so each 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 tool with only two parameters, full schema coverage, and an output schema, the description is nearly complete. The only notable gap is explicit guidance on when to choose this tool over related siblings, which prevents a perfect score.

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

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

With 100% schema description coverage, the baseline is 3, but the description adds meaningful context by limiting `text` to API, EVM RPC, or webhook errors and by mentioning sanitization. The `source` parameter remains adequately explained by the schema.

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

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

The description states a specific verb-resource pair: sanitize and match API, EVM RPC, or webhook errors to FixGraph, and it defines the output as machine-readable repair packets. It also distinguishes the tool from siblings by clarifying that it does not execute changes, so an agent can tell it apart from retrieval or action-oriented 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 implies when to use the tool: when the agent has a technical error and needs a matching repair packet. However, it does not explicitly route the agent away from sibling tools like get_repair_packet or list_fix_topics, and it does not state when not to use this tool.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior, so the description adds useful context about the capsule being signed and the state being sanitized. It does not disclose invalid-signature behavior or the shape of the unpacked result, but the annotations cover the 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?

One dense sentence front-loads the operation and resource, with every phrase serving a purpose. The terminology is compact but unexplained, which prevents a 5.

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 tool with strong safety annotations, the description is mostly sufficient, but it does not describe return values, error behavior, or how to choose this tool over verification/handoff siblings. An agent can infer the intent but not every operational detail.

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

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

The description adds domain meaning to the single capsule parameter by identifying it as a signed NAIF continuity capsule, which is useful given 0% schema description coverage. It does not explain serialization or validity requirements beyond the schema's length 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?

Clearly states a specific action chain (verify and unpack) on a specific resource (a signed NAIF continuity capsule) and names the intended outcome (another agent can resume from its sanitized state). It is not a tautology and is distinguishable from siblings, though it does not explicitly contrast with verify_handoff_capsule.

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 'so another agent can resume' clause provides a concrete use context: this tool is for resuming an agent task from a signed continuity capsule. It does not state exclusions or explicitly point to sibling tools for pure verification or handoff, but the usage scenario 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds a caution about interpretation ('Absence of a signal is not proof of health') but does not disclose additional behavioral aspects such as return format or potential rate limiting. Given the annotations cover the main behavioral profile, and the description adds a useful caveat, a score of 3 is reasonable.

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 with no superfluous words. The primary purpose is front-loaded in the first sentence, and the second sentence adds a critical interpretive caveat. Every word earns its place; this is a model of concise, structured writing.

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 being a relatively simple query tool, the description omits many necessary details: what 'route telemetry' actually represents, how to choose routeType/targetClass values, what the output looks like (no output schema exists), and any examples. The caveat is helpful but insufficient for an agent to confidently invoke this tool with correct parameters and interpret results. Completeness is inadequate.

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%, meaning the schema provides only type/enum/pattern constraints without descriptions. The tool description does not compensate by explaining any parameter semantics—it does not mention routeType, targetClass, chain, region, or windowMinutes. For a tool with 5 parameters (2 required), this is a significant gap. The description adds no meaning beyond the bare schema, so a score of 2 is warranted.

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

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

The description explicitly states the action (Query), the object (recent privacy-preserving aggregate route telemetry), and the context (before starting agent work). This clearly distinguishes it from sibling tools like get_agent_traffic_feed which presumably retrieves feed data, whereas this is a preflight check. The verb+resource is specific 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 provides a clear usage context by stating 'before starting agent work', indicating when this tool should be invoked. It does not explicitly mention when not to use it or name alternatives, but the preflight intent is clear. Since it gives a defined invocation scenario without exclusions, a score of 4 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, idempotentHint=true, and destructiveHint=false, covering safety and side-effect profile. The description adds behavioral context by specifying exactly what is checked (signature, validity window, state hash), which goes beyond the annotations. 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 a single, efficient sentence that front-loads the verb and resource, with no redundant words. Every phrase adds value, listing the specific verification aspects.

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 simple (one parameter, no nested objects), and annotations cover the safety profile. However, without an output schema, the description does not mention what the tool returns (e.g., boolean, status, error details). For a verification operation, this is a notable gap, though the low complexity keeps it from being severely incomplete.

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 clarify the parameter. It names the capsule as a 'NAIF continuity capsule', which gives semantic meaning beyond the raw string type. However, it does not explain the expected format, encoding, or how the capsule string relates to the verified aspects. For a single simple parameter, this is adequate but not thorough.

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 ('Verify') and resource ('NAIF continuity capsule') and lists precisely what is verified: signature, validity window, and embedded state hash. This distinguishes it from siblings like create_handoff_capsule and verify_trust_token, which operate on different concepts.

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 context (when you have a capsule to verify) but does not explicitly say when to use this tool versus alternatives like verify_trust_token, nor does it mention any preconditions or exclusions. It leaves the agent to infer that this is the right tool for handoff capsule verification.

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 reveal that the tool is read-only, idempotent, and non-destructive. The description adds that it verifies signature and validity window, but it does not disclose what happens with an invalid or expired token, such as returning false versus throwing an error. This matters because there is no output schema.

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

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

One concise sentence with no filler. The core operation and token types are front-loaded, making the purpose immediately clear.

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 definition is mostly adequate for a simple read-only verifier, but because there is no output schema, the missing description of the return value or error behavior is a notable gap. Token provenance and expected response format are also not addressed.

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 only defines 'token' as a string with length constraints. The description adds meaningful semantics by identifying it as a NAIF Trust Passport or Delegation Preflight token, which is sufficient context for the single parameter.

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

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

States a specific verb 'Verify' and a clear object: 'the signature and validity window of a NAIF Trust Passport or Delegation Preflight token.' This clearly distinguishes the tool from siblings like delegation_preflight or get_agent_trust_passport, which generate or retrieve tokens rather than verifying them.

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 validating an existing token, but it does not explicitly state when to use this tool over alternatives or when not to use it. No exclusions or comparison with sibling tools are provided.

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