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

No annotations are provided, so the description carries the full burden. It implies a read/explain operation but never states that it is non-mutating, whether it requires a valid hydration_id, or what happens on an unknown id. Only the vague mention of 'fidelity gates' gestures at 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?

One tight sentence with the action and output front-loaded, no filler. It is arguably too terse given the undefined jargon, but structurally efficient.

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?

An output schema exists, so return values needn't be explained, and the tool is a simple one-parameter read. Still, with no annotations and an undocumented parameter, the description leaves the agent without enough to confidently invoke it.

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 single required parameter 'hydration_id' is undocumented in both schema and description. The description adds no meaning about what a hydration id is or where the caller obtains it, so it fails to compensate for 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?

States a specific verb ('Explain') and resource ('selected and omitted resources'), plus the nature of the output ('score components and fidelity gates'). It distinguishes itself from siblings like get_context and thread_stats, though the jargon is unexplained.

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 call this versus alternatives such as get_context, nor any prerequisite or trigger condition. The agent must infer usage purely from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden. "Read" weakly implies a non-mutating operation, but nothing is said about permissions, whether the envelope is cached or freshly computed, or what "canonical" implies in terms of freshness or resolution.

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 sentence is appropriately front-loaded and wastes no words, but here the brevity reflects under-specification rather than disciplined concision — the one sentence is the entire content of the definition.

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

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

An output schema exists, so return values need not be explained. Still, with zero annotation coverage, an undocumented parameter, and heavy reliance on undefined jargon, the definition is not complete enough for an agent to call this correctly without guessing.

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% for the single required hydration_id parameter, so the description must compensate. It only echoes the concept ("a hydration identifier") without giving format, source, or how to obtain a valid value, adding essentially no meaning beyond the parameter name.

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?

"Read the canonical envelope for a hydration identifier" gives a verb (Read) and an object (canonical envelope), so it is marginally more than a tautology. However, "hydration identifier" and "canonical envelope" are undefined internal jargon, so an agent cannot confidently distinguish this from siblings like hydrate_message or resolve_resource_version.

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 when-to-use guidance, no prerequisites, and no mention of any alternative tool. The agent is left to infer the relationship to hydrate_message and the other hydration-related siblings entirely on its own.

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

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

No annotations are provided, so the description carries the full disclosure burden. 'Source-preserving' hints at a fidelity guarantee, but nothing is said about side effects, required permissions, what compaction modes do to content, whether anything is mutated or persisted, or how token budgets affect output.

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 single sentence is short, but this is under-specification rather than conciseness — brevity achieved by omitting the information the agent needs. Nothing is front-loaded beyond an opaque phrase.

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

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

With an output schema present, return values need not be explained, but a nine-parameter tool with zero annotation and zero schema-description coverage requires far more than one sentence. The description supplies essentially none of the context needed to call it correctly.

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

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

Nine parameters at 0% schema description coverage, and the description mentions none of them. Mode (with four enum values), adapter, use_local_model, and the two token-budget integers all go entirely unexplained, leaving the agent unable to invoke the tool meaningfully.

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 verb 'compile' and the object 'prompt envelope' gesture at a resource, but 'source-preserving prompt envelope' is undefined jargon the agent cannot map to a concrete operation. It never says what is actually produced or how it relates to siblings like get_context or explain_selection.

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 when-to-use guidance, no stated scenario, and no differentiation from the six sibling tools (get_context, explain_selection, thread_stats, etc.). The agent is left to infer that this is a message-preparation step with no exclusions or alternatives named.

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 behavioral burden. It usefully discloses idempotency and that totals are returned, but doesn't say what happens on a duplicate idempotency_key, whether it requires auth, or how concurrent writes behave — gaps for a mutation tool.

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 earns its place and the key behavioral trait (idempotency) leads.

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?

An output schema exists, so return values need no explanation. But for a 10-parameter mutation tool with zero annotation coverage and zero schema descriptions, this one-liner leaves too much unspecified about its arguments and write 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?

Schema description coverage is 0% across 10 parameters, and the description compensates only vaguely through the phrase 'provider-observed usage.' Nothing explains the token fields, idempotency_key semantics, hydration_id, or which of the many optional token params matter when.

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 (record) and resource (provider-observed usage) and adds the return value (updated thread totals). It's clear what the tool does, but it never differentiates itself from siblings like thread_stats or hydrate_message, which handle related thread/token 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 gives no when-to-use guidance, no conditions, and no alternatives. An agent must infer from the name alone that this is for logging observed token usage rather than reading it (thread_stats) or hydrating messages.

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 must disclose behavioral traits. It hints that the content is 'immutable' and 'sanitized', implying a safe read, but does not state side effects, authentication needs, error handling, or whether the operation is read-only. Significant gaps remain.

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 with no wasted words. It is appropriately sized, though the conciseness comes at the cost of clarity.

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 two required parameters, no annotations, and an output schema, the description is incomplete. It omits parameter meaning, usage context, and behavioral details, leaving the agent with insufficient information to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'omission recovery reference' but does not explain what resource_id or version_id represent or how they should be supplied. No meaningful parameter semantics are provided.

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 verb ('Resolve') and a resource ('immutable sanitized content'), but the qualifier 'from an omission recovery reference' is opaque jargon that does not clarify the tool's function or distinguish it from siblings. It is not a tautology, but the purpose remains vague.

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 offers no guidance on when to use this tool versus alternatives like hydrate_message or get_context, nor any prerequisites or exclusions. The agent is left to infer usage entirely.

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

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

No annotations are provided, so the description carries the full burden. 'Read' implies a non-mutating operation and 'lifetime' hints at cumulative rather than point-in-time metrics, which is useful; but there is no disclosure of auth requirements, scope limits, or what confidence separation entails. An output schema exists, so return-format details are rightly omitted.

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. It is appropriately sized for a one-parameter read tool, though 'confidence-separated' could be replaced with plainer language that earns its place more clearly.

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

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

For a simple one-parameter read tool with an output schema, the description covers the essentials. What is missing is any usage context or clarification of the 'confidence-separated' terminology, leaving the agent with gaps in 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?

One parameter (thread_id) with 0% schema description coverage. The name is largely self-explanatory and the description scopes it to 'one thread', but it adds no syntax, format, or sourcing guidance beyond what the schema already conveys.

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 (read) and resource (lifetime token metrics scoped to one thread), so an agent can tell it apart from siblings like record_usage or workspace_status. However, the modifier 'confidence-separated' is unexplained jargon that leaves the exact metric breakdown ambiguous.

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 indication of when to reach for this tool versus alternatives such as workspace_status or record_usage, nor any prerequisites. The agent must infer usage entirely from the name and the single required parameter.

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

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

No annotations are provided, so the description carries the full burden. 'Read' implies a safe read-only operation, which is useful, but it omits auth requirements, rate limits, and whether status is cached or live. It adds some behavioral context beyond schema but not full transparency.

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?

Single front-loaded sentence with no filler; every word contributes to defining the tool's scope.

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?

An output schema exists, so return values are covered. However, with no annotations and no parameter description, the description leaves gaps about the required workspace_id and when to choose this over sibling tools. Adequate but 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%, and the description does not mention workspace_id at all. The single required parameter is left undocumented in both the schema and the description, so the description does not compensate for 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?

Specific verb 'Read' and a clear scope of status aspects (active generation, freshness, synchronization). However, it does not differentiate from siblings like thread_stats or get_context, so it falls short of a 5.

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

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

No when-to-use guidance or alternatives are provided. The description simply states what the tool reads, leaving the agent to infer the appropriate context.

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