Atomadic MCP

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

With no annotations, the description carries the full behavioral burden and delivers little: it does not say what the output looks like (a verdict, a list of conflicting pairs, a score), whether the operation is read-only, or how many statements are expected. "Agent outputs" is the only scoping detail provided.

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 short sentence with no waste and the purpose front-loaded, which is structurally fine. However, brevity here borders on under-specification rather than tight writing, so it is merely adequate.

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?

No annotations, no output schema, and a parameter with zero description coverage means the description should explain the interaction contract and the shape of results. It explains neither, leaving the caller unable to predict what a contradiction report contains.

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% for the single `statements` parameter. The description says the input is "agent outputs" but adds no semantics about ordering, count limits, language, or whether each string is an independent claim. The example in the schema does more work than the description.

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 and resource: "Detect contradictions in agent outputs." The "[agents]" prefix scopes it to agent outputs, but the description does nothing to distinguish it from the near-identical sibling `detect_contradiction`, which appears to cover the same operation. Clear purpose, 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?

There is no guidance on when to use this tool versus `detect_contradiction`, nor any precondition such as minimum statement count or whether statements must come from the same agent run. 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 behavioral burden, and it discloses nothing: not the taxonomy of intents returned, whether it is deterministic, latency, or any side effects. For a classification tool with zero annotation coverage this is a complete gap.

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 text is short but under-specified rather than concise; the "[agents]" prefix is noise and the remaining phrase is a bare noun phrase with no front-loaded actionable content.

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 no annotations, no output schema, and 0% parameter coverage, the description should explain the intent taxonomy, input expectations, and return shape. It supplies none of these, leaving an agent unable to call the tool correctly.

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

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

Schema description coverage is 0% and the single required parameter "text" is undocumented beyond a schema example. The description adds no meaning about what the text should be (agent instruction, user utterance, log line) or any format expectations, 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?

The description restates the tool name ("[agents] Agent intent classification") without adding a verb, scope, or output form. An agent learns nothing beyond what the name already implies, and nothing distinguishes it from siblings like text_sentiment, text_keywords, or detect_contradiction.

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 statement of when to use this tool, no prerequisites, and no mention of alternatives among the many text/agent-classification siblings. The agent must guess 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: no side effects, no cost/latency implications of an LLM-driven planning call, no determinism, no auth requirements. Five words of noun phrase give an agent no basis for predicting what invoking this does.

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?

It is short, but the brevity comes from under-specification rather than efficiency; the single phrase is a label, not a front-loaded statement of purpose. No information is structured for an agent to act on.

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 that takes a nested free-form constraints object, has no output schema, and no annotations, the description is completely inadequate. Nothing tells the agent what a returned 'plan' looks like or what happens after planning is produced.

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 50% — 'goal' has only an example and no description, while 'constraints' (a free-form additionalProperties object) is documented. The description adds nothing about what a goal string should contain or how constraint keys are interpreted, 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?

The description '[agents] Autonomous agent goal planning' is essentially a restatement of the tool name agents_plan with a namespace prefix; it names no verb and no outcome. It does not distinguish this tool from the many sibling agents_* tools (agents_intent_classify, agents_topology, agents_register), so an agent cannot tell what planning uniquely produces here.

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 alternatives among ~60 siblings. The only hint is the word 'autonomous', which is not enough to route an agent between this and e.g. agents_intent_classify or route_capability.

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, and it discloses almost nothing. It does not say whether registration is idempotent, whether it overwrites an existing agent_id, whether authentication is required, or what happens on duplicate registration. 'Register' minimally implies a write, which is the only behavioral signal offered.

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?

At four words the text is not bloated, but this is under-specification rather than conciseness. There is nothing to front-load because no substantive information is present.

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 two-required-parameter mutation tool with no annotations, no output schema, and no parameter documentation, the description is materially incomplete. An agent cannot determine success behavior, error conditions, or the meaning of the required capabilities array from this definition.

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 explains neither agent_id nor capabilities. The only clues are the schema's example values ('my-agent-001', ['inference','planning','code-generation']), which let an agent guess at format but not at constraints such as allowed capability strings or uniqueness 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 states a specific verb and resource ('Register an agent'), so the action is identifiable. However, it says nothing about what registration produces (an ID, a credential, a reputation entry) or how it differs from the many sibling register tools such as ratchet_register and sla_register. Minimum viable but not distinguishing.

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 alternatives such as identity_verify or ratchet_register. The agent must infer the entire invocation context from the tool 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not whether this is a read or a mutation, not whether the agent must be registered first, not what the trust score range means, and not whether the score is cached or live.

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?

It is a single short tag-prefixed phrase with no waste, but the brevity comes from under-specification rather than tight writing; there is nothing front-loaded because there is nothing to front-load.

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 no annotations, no output schema, and no parameter documentation, the description leaves an agent unable to call this confidently or interpret the result. For a reputation/trust lookup it should at minimum state that it is a read and describe what score is returned.

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 expected to compensate, but it says nothing about agent_id. The parameter name and example make the intent largely self-evident, but no format, lookup, or scoping semantics are added beyond the schema.

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

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

The description names a resource (agent reputation/trust score) and the [agents] prefix ties it to the agents_* family, distinguishing it from the similarly named trust_score and receipt_reputation siblings. However, it states no verb, so an agent cannot tell whether this reads, computes, or updates a reputation score.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no routing hints toward alternatives such as trust_score, trust_history, or reputation_record. The agent must infer usage entirely from the tool 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 burden of behavioral disclosure. It implies a comparison operation but says nothing about whether it is read-only, what it returns, whether any state is mutated, or what permissions are needed.

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 phrase with no wasted words. It is structurally clean, though its brevity contributes to gaps in other dimensions rather than being a conciseness problem itself.

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 no annotations, no output schema, and 0% parameter description coverage, the one-line description is far too thin for an agent to invoke the tool correctly. It does not describe the required inputs, the optional context parameter, or the return value.

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 explain the parameters. It loosely implies two outputs (mapping to output_a and output_b) but does not explain them, and it never mentions what the optional 'context' parameter does.

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 ('semantic diff') and resource ('agent outputs'), so the basic operation is clear. However, it does not differentiate this tool from siblings such as agents_contradiction or detect_contradiction, which also compare or analyze text/outputs.

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 about when to use this tool versus alternatives, nor any preconditions or exclusions. The phrase 'between agent outputs' implies the general context but leaves selection entirely 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. "Live" is the only behavioral signal and it implies real-time freshness, but the description never says whether the call is read-only, whether it reflects instantaneous state or a window, or how heavy/frequent polling should be. For a zero-parameter, annotation-free tool this is thin.

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

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

A single four-word phrase with zero filler, and the most important token ("live") is front-loaded after the namespace tag. It is efficient, though its brevity shades into under-specification rather than disciplined concision.

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 no annotations, no output schema, and no parameters, the description is the only source of information an agent has — and it does not say what the topology contains (nodes, agents, links), what shape the response takes, or how the swarm is identified. That is a real gap for a tool an agent must call blind.

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 takes zero parameters, which per the rubric sets a baseline of 4, and the empty schema leaves no parameter semantics for the description to supplement. There is nothing the description could add here.

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 the resource (swarm topology) and qualifies it as "live," which tells an agent this is a real-time view rather than a historical or static one. However, it is a bare noun phrase with no verb, so it never states what the tool actually does with that topology (returns it, streams it, renders it). It also does not differentiate itself from adjacent read-style siblings such as agents_reputation or trust_score.

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

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

There is no when-to-use guidance, no conditions, and no named alternative among the many agents_* siblings. The single word "live" faintly hints that this is a current-snapshot call, but nothing tells an agent when to prefer it over agents_plan, agents_reputation, or swarm_inbox.

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 and does it well: it discloses determinism, the three outcome states (GREEN/RED/UNVERIFIED), the meaning of RED as 'tampered', and a rate limit (3 free calls/day then entitlement 'ledger'). It omits explicit auth/permission requirements beyond the entitlement note, but this is strong disclosure overall.

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?

Dense and front-loaded: purpose, mechanism, outcome states, and quota all land in a few tight sentences. The bracketed product/entitlement prefix and repeated entitlement mention are slightly redundant but 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 no-annotation, no-output-schema tool this is nearly complete: it explains the mechanism, the return states (standing in for the missing output schema), and the quota. Only explicit auth/permission prerequisites and the structure of the nested 'inputs' payload remain 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 coverage is 100% and both parameters are documented in the schema, including the UNVERIFIED-on-omission behavior. The description matches the schema rather than adding meaningful new parameter semantics, so baseline 3 applies.

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 (recompute-audit) and resource (agent work claim), then nails the mechanism: re-derive a deterministic SHA-256 digest from claimed inputs and check it against the claimed digest. This is clearly distinguishable from siblings like agents_contradiction, drift_certificate, or agents_reputation.

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 verification intent ('replay, not opinion') implies when to reach for it, but there is no explicit when-to-use / when-not guidance and no named alternative among the many sibling audit/verify tools. Usage is inferable but not spelled out.

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 supplied, so the description carries the full disclosure burden. The word 'gate' hints that this check can block or deny an operation, but the description never says what happens on failure, whether it is read-only or enforcing, what permissions are needed, or whether results are cached/logged. This is a significant gap for a mutation-adjacent enforcement 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?

The description is a single bracketed fragment with no wasted sentences, but the brevity comes at the cost of specification rather than being efficiently front-loaded. It reads like a tag line, not a usable tool description.

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 three required, undocumented parameters, no annotations, and no output schema, the description supplies essentially none of the information an agent needs to invoke it correctly. Neither input semantics, enforcement behavior, nor output expectations are covered.

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 all three parameters (data_type, operation, jurisdiction) are required, yet the description says nothing about their meaning or accepted values. Examples like 'user_pii', 'store', and 'EU' are the only hint of valid inputs, and no enums exist, so the description fails to compensate for the total documentation 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 fragment '[security] GDPR/CCPA compliance gate' names a resource (compliance) and a domain (GDPR/CCPA) and implies a gatekeeping/check operation, which loosely separates it from compliance_eu_ai_act and compliance_fairness. However, there is no verb and no statement of what the tool actually returns or does, so the purpose is only implied rather than stated.

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, no prerequisites, and no routing to alternatives is provided, despite many sibling compliance_* tools (compliance_explain, compliance_oversight, compliance_eu_ai_act) that an agent must choose between. The agent is given nothing to decide when this gate applies versus those.

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, and it discloses nothing: not whether this is a read-only lookup or a state-changing certificate issuance, not permission or auth requirements, not what is returned or persisted. A six-word label for a three-required-parameter operation is inadequate.

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?

It is short with no wasted words, but this is under-specification rather than conciseness; a six-word noun phrase for a required-parameter compliance tool leaves the agent with almost nothing to act on.

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 no output schema, no annotations, three required parameters at 0% coverage, and only a bracketed category tag plus a noun phrase, the definition is nowhere near complete enough for an agent to invoke it correctly.

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

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

Schema description coverage is 0% and the description names none of the three required parameters (system_id, risk_category, intended_purpose). The enum on risk_category is self-evident from the schema, but the semantics of system_id and intended_purpose — formats, where they come from, how they affect the certificate — are documented nowhere.

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 phrase "EU AI Act compliance certificate" is essentially a restatement of the tool name with the noun "certificate" added; there is no action verb to say whether it issues, verifies, or looks up a certificate. Nothing distinguishes it from close siblings such as compliance_check, compliance_explain, or drift_certificate. It borders on tautology with only a faint hint of the resource area.

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 when an agent should pick this over compliance_check or the other compliance_* siblings. The only implicit signal is the EU AI Act domain, which is not enough to route an agent correctly.

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, and it discloses nothing: not whether this reads or writes, whether the certificate is generated or merely fetched, whether it is expensive, what permissions are needed, or what is returned (no output schema either). 'Certify/explain' tools are typically heavy operations, and none of that is conveyed.

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?

It is short, but brevity here is under-specification rather than conciseness — the single fragment conveys no actionable content, and the '[security]' tag and internal codename consume the space that should hold the 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?

For a 3-required-parameter tool with a nested object, no annotations, and no output schema, the definition provides nothing an agent needs to invoke it correctly. The gap is total rather than marginal.

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?

Three required parameters with 0% schema description coverage, including a nested 'subject_context' object, and the description explains none of them. It adds zero meaning beyond the raw parameter names, leaving the agent guessing at formats for model_id, decision_id, and the nested context.

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 is a noun phrase plus an internal codename ('Explainability certificate (XPL-100-ExplainBound)') that largely restates the tool name compliance_explain. There is no verb and no statement of what the tool actually produces or does, so an agent cannot distinguish it from siblings like compliance_transparency or compliance_check.

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, no prerequisites, and no mention of any alternative tool. The agent is given nothing to decide between this and the many other compliance_* 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?

Annotations are absent, so the description carries the full behavioral burden, and it discloses nothing: no permission requirements, no indication of whether a proof is computed, stored, or merely validated, no cost/latency hints, and no side-effect profile. Nothing beyond a two-word label is provided.

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 short but that brevity reflects under-specification rather than economy; there is no wasted sentence, but also no informative one. The single fragment is front-loaded only in the trivial sense of being one line.

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 four-parameter required tool with no annotations and no output schema, the definition supplies essentially no information an agent needs to invoke it correctly. It cannot determine valid metric values, the semantics of protected_attrs, or what the tool returns.

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?

Four required parameters (model_id, dataset_id, protected_attrs, metric) with 0% schema description coverage, and the description explains none of them. "metric" shows only a single example value (demographic_parity) with no enumeration of valid metrics, and protected_attrs' expected format is entirely undocumented.

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?

"Fairness proof (FNS-100-FairnessBound)" names a resource (fairness) and a standard identifier, but the name already says "fairness" and the tag "[security]" adds little. There is no verb, so an agent cannot tell whether this generates a proof, verifies one, or reports a metric, nor how it differs from compliance_check or compliance_transparency.

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, when-not-to-use, or prerequisite statements are given. The only implied guidance is the "[security]" tag and the FNS-100 reference, which hint at a compliance context but do not tell the agent when this tool is the right choice versus its many compliance_* and trust_* 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?

No annotations are provided, so the description carries the full burden and delivers almost nothing: it does not say whether the report is immutable, who is notified, whether auth/permissions are required, or what happens to the 4 required inputs. 'Report' weakly implies a write, but the behavioral surface is essentially undisclosed.

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?

Only one short clause, so it is front-loaded with no padding, but the brevity reflects under-specification rather than disciplined conciseness; the '[security]' tag consumes words without adding meaning.

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

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

A four-required-parameter mutation tool with no annotations, no output schema, and no parameter documentation needs the description to supply the missing context; a six-word tag plus phrase leaves the agent without enough 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?

Four required parameters with 0% schema description coverage and no parameter guidance anywhere in the description. severity's enum is the only self-documenting field; system_id, description, and affected_users have no stated format, source, or 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?

States a verb (Report) and resource (compliance incident), so the basic action is inferable, but the bare '[security]' prefix is a tag rather than differentiation and nothing separates it from the sibling 'compliance_incidents', which plausibly lists the incidents this tool files.

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, no prerequisites, and no pointer to the near-identical sibling compliance_incidents. The agent must guess whether this creates a new incident or queries existing ones.

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 at all, the description carries the full behavioral burden and delivers nothing: it does not say whether this reads or writes incidents, whether auth is required, what a 'registry' lookup returns, or how it behaves for an unknown system_id.

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?

It is short, but that brevity is under-specification rather than conciseness — there is no useful content to front-load. A two-word fragment cannot earn its place as a tool description.

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?

No annotations, no output schema, and one undocumented required parameter means the description is the only channel for context, and it supplies none. An agent cannot determine what calling this tool does or returns.

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 explain the single required parameter 'system_id' — what identifier format it expects, whether it refers to an agent, model, or deployment. It adds no parameter meaning whatsoever.

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 'Incident registry' merely restates the tool name in noun form with no verb and no stated action (list? create? query?). It is also easily confused with the sibling 'compliance_incident' (singular), and nothing distinguishes the two.

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 condition selecting this tool over 'compliance_incident' or the other compliance_* siblings, and no prerequisites. The agent is left to guess 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 entire behavioral burden, and it discloses nothing: not whether the call is read-only or mutating, what a chain-integrity check verifies, whether it consumes a registered model, or what authorization or cost it implies. A bracketed category tag is not behavioral disclosure.

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?

It is short, but this is under-specification rather than conciseness — nothing useful is front-loaded because nothing useful is stated at all. The fragment is only a category label plus a code.

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 no annotations, no output schema, and two required parameters at 0% coverage (one being an untyped object array), the description is completely inadequate for invoking the tool correctly. An agent could not construct a valid, meaningful call from this text.

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 both parameters are required, yet the description never mentions model_id or dataset_stages. The array-of-untyped-objects parameter is especially opaque, and the description adds zero syntax, format, or structural meaning beyond the raw schema types.

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 resource category ('Data lineage') but supplies no verb and no statement of what the tool actually does with lineage data. The internal tag '(LIN-100-ChainIntegrity)' is a control identifier, not an explanation, and it does nothing to distinguish this tool from ~15 sibling compliance_* and audit_* 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?

There is no guidance on when to use this tool, when not to, or which sibling (compliance_check, compliance_explain, compliance_eu_ai_act, drift_certificate, etc.) it should be preferred over. An agent has no basis for routing between these 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Log oversight event' implies a write/audit action, but it does not state required permissions, whether the event is immutable, what side effects occur, or what happens to existing data.

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 short fragment with no wasted words, but it is under-specified rather than appropriately concise. For a tool with four required parameters and no annotations, far more structural detail is needed.

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 no annotations, no output schema, 0% parameter description coverage, and four required parameters, the description is completely inadequate for correct invocation. It omits almost everything an agent would need to use the tool safely and 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% and all four parameters are required, yet the description adds no meaning for system_id, reviewer_id, decision, or notes. It does not compensate for the completely 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 states a verb and resource: 'Log oversight event.' However, 'oversight event' is vague, and the description does not distinguish this tool from the related sibling compliance_oversight_history or explain what kind of oversight is being logged.

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 versus alternatives such as compliance_oversight_history or compliance_check. The only context is the '[security]' tag, which indicates a category but not usage conditions or prerequisites.

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 of behavioral disclosure, and it discloses nothing. It does not say whether this is a read operation, what the history contains, whether access is restricted, or how results are scoped.

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?

It is only four words, but this is under-specification rather than conciseness. Nothing is front-loaded because nothing of substance is present.

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 no annotations, no output schema, and an undocumented required parameter, the description leaves an agent without enough information to invoke this tool correctly or interpret its 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 single required parameter system_id has 0% schema description coverage and the description adds no meaning for it. An agent cannot tell what identifier format is expected or which system namespace it refers to.

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 "[security] Oversight history" merely restates the tool name compliance_oversight_history in plainer words with a topical tag. It gives no verb, no stated scope, and nothing to distinguish it from siblings like compliance_oversight or trust_history.

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 compliance_oversight, compliance_incidents, or any other compliance sibling. No prerequisites, no exclusions, no context is provided.

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 and the description carries the full burden, yet it discloses nothing about behavior: no read vs write semantics, no permission or auth requirements, no rate limits, no indication of whether the report is generated, cached, or persisted.

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 phrase is short but under-specified rather than concise; the '[security]' tag consumes space without conveying meaning for tool selection. There is no front-loaded action or 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?

For a tool with three required parameters, zero schema descriptions, no annotations, and no output schema, the description is entirely inadequate. Nothing an agent needs to invoke it correctly is present.

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

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

All three required parameters (system_id, period, include) have 0% schema description coverage, and the description compensates for none of them. It does not explain the period format (only an example '2026-Q1'), what values the include array accepts, or what system_id refers to.

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 "[security] Transparency report" restates the tool name rather than specifying an action and resource. It gives no verb (generate? fetch? view?) and no sense of what the report covers, so an agent cannot distinguish it from the many compliance siblings.

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 versus compliance_incident, compliance_oversight, compliance_fairness, or compliance_explain, which appear to overlap heavily with a 'transparency report'. No prerequisites or exclusions are 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it discloses nothing. It does not say whether this is a read-only verification or a mutating action, what authorizations or credentials are required, whether it is idempotent, or what happens on failure.

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 text is short, but its brevity comes from under-specification rather than conciseness. An opaque internal code is not a substitute for a front-loaded statement of what the tool does.

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 five-required-parameter tool with no annotations, no output schema, and no parameter documentation, so the description must supply everything and supplies nothing. An agent cannot safely construct a call from this definition.

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

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

All five parameters (bridge_id, source_chain, dest_chain, amount, token) have 0% schema description coverage, and the description adds no meaning for any of them. Formats, accepted chain identifiers, token notation, and units for amount are all entirely undocumented.

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 reduces to a domain tag ('[defi]') plus a label ('Bridge Proof') and an internal protocol code ('BRP-100-BridgeIntegrity'). It never states a verb or the actual operation being performed, and gives no basis for distinguishing it from siblings like defi_oracle_verify, defi_contract_audit, or rng_verify.

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 whatsoever on when to call this tool, what preconditions must hold, or which sibling to prefer for adjacent tasks. The codename 'BRP-100-BridgeIntegrity' offers no actionable selection criteria.

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 of behavioral disclosure, and it discloses nothing: whether this is read-only, whether it mutates state, whether authentication or a chain connection is required, whether it is rate-limited, or what a result looks like. For a security-adjacent audit tool this is a critical gap.

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 text is short, but its brevity reflects under-specification rather than economy; there is nothing front-loaded because there is essentially nothing stated. It cannot be considered efficient when it omits everything an agent needs.

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 no annotations, no output schema, 0% parameter documentation, and two required parameters, the definition is completely inadequate. The description would need to explain the audit behavior, inputs, and result shape, and it does none of that.

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 both parameters (contract_id, contract_type) are undocumented in the schema. The description supplies no meaning for either, not even the expected format of contract_id or the allowed values for contract_type beyond an 'erc20' example in the schema.

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

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

The description '[defi] Contract Verify (CVR-100-AuditBound)' essentially restates the tool name defi_contract_audit, swapping 'audit' for 'verify' without adding scope or distinguishing it from siblings like defi_bridge_verify, defi_oracle_verify, or defi_risk_score. The bracketed prefix and opaque code 'CVR-100-AuditBound' convey no actionable meaning about what is actually verified or returned.

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 versus the many defi_* and *_verify siblings, nor any prerequisites, exclusions, or context. An agent has nothing to route on beyond the name itself.

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 of behavioral disclosure, and it discloses nothing: not whether it is read-only, whether it mutates state, what permissions it needs, or what it returns. The label "Shield" is ambiguous and could even suggest a protective action rather than an evaluation.

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?

It is short, but that brevity reflects under-specification rather than economy of expression; there is no informative content front-loaded for the agent to act on.

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 four-required-parameter financial calculation tool with no annotations, no output schema, and no documented parameters needs a substantial description, and this provides none. An agent has no basis for calling 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?

All four parameters (position_id, collateral_value, debt_value, collateral_factor) have 0% schema description coverage, and the description supplies no parameter semantics at all — no units, no expected ranges, no explanation of how collateral_factor is expressed.

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 is only the branded label "Liquid Shield (LQS-100-LiquidationBound)", which restates the tool name in marketing jargon rather than stating a verb+resource. An agent can guess this relates to liquidation from the name, but the description itself adds no operational meaning and does not distinguish it from defi_risk_score or defi_optimize.

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, when not to, or which sibling to prefer for related DeFi risk analysis. Nothing in the text hints at prerequisites or context of use.

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 of behavioral disclosure, and it discloses nothing: not whether the call is read-only or mutates state, whether it requires authorization or a funded position, what it returns, or what happens on failure. For an optimization tool with a nested position object, this is a complete transparency gap.

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 fragment with no wasted words, but this is under-specification rather than conciseness. Brevity does not earn credit when the content needed to invoke the tool correctly is absent.

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 DeFi optimization tool with nested inputs, no annotations, no output schema, and 0% parameter documentation, the description supplies none of the context required to invoke it safely or interpret its result. What exists is a label, not a usable specification.

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 there are three required parameters including a nested object, so the description must compensate for the schema gap. It adds nothing about protocol identifiers, the position structure, or the valid range/units of the risk_tolerance float, leaving all semantics to the bare schema examples.

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 high-level purpose ("LP parameter optimization"), which is more specific than the bare tool name and situates it in the liquidity-pool domain. However, it never says what is optimized toward, what the output is, or how it differs from the near-identical sibling defi_yield_optimize. The "(DFP-100-OptimalTick)" token is opaque jargon that adds no meaning for an agent.

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 the competing defi_yield_optimize or defi_risk_score tools. An agent has no basis for choosing between defi_optimize and defi_yield_optimize from the text 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not whether verification is read-only or mutating, not what auth or on-chain calls it performs, not rate limits, and not what happens on a failed check.

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?

It is short, but this is under-specification rather than conciseness; the single fragment includes an unexplained internal identifier instead of substantive content front-loaded for selection.

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 five-required-parameter tool with no annotations, no output schema, and no parameter documentation, the description leaves an agent with essentially nothing needed 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?

All five parameters (oracle_address, price_feed, reference_price, asset, tvl_at_risk) are required with 0% schema description coverage, and the description adds no meaning for any of them — notably reference_price units and tvl_at_risk usage are entirely undocumented.

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 is essentially a restatement of the tool name plus an opaque internal label: '[defi] Oracle guard (OGD-100-ManipulationBound)'. It hints at oracle price-manipulation protection but states no verb and no concrete action, so an agent cannot tell exactly what the 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?

There is no guidance on when to call this tool, when not to, or how it relates to siblings such as defi_risk_score, defi_liquidation_check, or defi_bridge_verify. The 'OGD-100' code provides no actionable routing information.

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, yet it discloses nothing: not whether scoring is deterministic, what inputs feed it, permissions required, or what a risk score represents. The spec code 'DFI-101-RiskScoreBound' hints at bounds but is unexplained.

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?

Extremely short, but this is under-specification rather than conciseness — there is essentially no content to front-load. The only non-name token is an internal spec identifier.

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 requiring three parameters, including two nested objects with zero documentation, no output schema, and no annotations, the description is completely inadequate. An agent cannot call this correctly without external knowledge of the DFI-101 spec.

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 three required parameters, two of which are untyped nested objects (position, market_conditions). The description adds no field-level meaning, so an agent has no idea what shape to supply for the object parameters.

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 'DeFi risk scoring' essentially restates the tool name (defi_risk_score) rather than specifying what is scored or how. The parenthetical 'DFI-101-RiskScoreBound' is an opaque spec identifier that conveys no meaning to an agent. It does not differentiate from siblings such as defi_contract_audit, defi_liquidation_check, or threat_score.

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

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

There is no guidance on when to use this tool versus the many other defi_* risk-adjacent siblings (defi_contract_audit, defi_liquidation_check, defi_oracle_verify). No prerequisites, no exclusions, no 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?

No annotations are provided, so the description carries the full burden, and it discloses nothing: not whether this reads state, moves funds, or requires authorization. For a DeFi tool taking a principal amount, the absence of any statement about whether it executes or merely computes is a serious gap.

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?

It is short, but this is under-specification rather than conciseness — the single fragment is a codename, not a front-loaded statement of function, so it earns its brevity for the wrong reason.

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 no annotations, no output schema, and 0% parameter coverage, the description needed to supply purpose, behavior, and parameter meaning, and it supplies none of them.

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% for two required parameters. The description adds nothing about principal_usd units/bounds or what risk_tolerance's 0-1 float scale means, leaving both parameters undocumented in both schema and description.

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 is essentially the tool name restated as a tag plus codename: '[defi] Yield Oracle (YLD-100-YieldConvergence)'. 'Yield Oracle' hints at the DeFi yield domain, but there is no verb or statement of what the tool actually does — optimize, quote, verify, or aggregate yields. An agent cannot distinguish it from siblings like defi_optimize or defi_oracle_verify.

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, no preconditions, no mention of alternatives such as defi_optimize or defi_risk_score. The agent is given nothing to route on.

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 and largely meets it: it discloses the decision behavior (RED/GREEN), determinism and recomputability, and a concrete rate limit plus entitlement gate. It stops short of describing the return payload structure or error behavior on malformed claims.

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?

Dense but efficient: the product/entitlement tag, the purpose and rule, then behavior and rate limit, each in one clause. Every sentence carries information, front-loading the entitlement context before the operation.

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, no-output-schema tool, the description covers purpose, the contradiction rule, result semantics, determinism, and cost/entitlement gating. The remaining gap is a brief statement of the return format, which matters since no output schema exists.

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

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

Schema coverage is 100% and the single `claims` parameter is already described in the schema (key/subject and value). The description clarifies the evaluation semantics (conflicting values on the same key), which adds some meaning, but the baseline of 3 is appropriate given the schema does the structural work.

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+resource: 'Detect contradictions across structured claims,' with an explicit rule (same key, conflicting values → RED, else GREEN). An agent immediately understands the operation. It does not, however, distinguish itself from the sibling `agents_contradiction`, so it stops 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?

There is no when-to-use guidance or named alternative, even though a similarly named sibling (`agents_contradiction`) exists and would be the obvious confusion point. The only usage-related content is commercial ('3 free calls/day, then entitlement ledger'), which describes cost, not selection criteria.

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, and it discloses nothing: not whether the call is read-only, what a 'certificate' contains, whether it is idempotent, what permissions the id requires, or what happens on an unknown id. This is a complete transparency gap for a tool with zero structured support.

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 text is short but not concise in the useful sense — it is under-specified rather than economical, containing a namespace tag and a noun phrase with zero information. There is no front-loaded statement of action to be concise about.

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 annotations, no output schema, and 0% parameter documentation, the description needed to carry everything and carries nothing. An agent has no basis to decide whether to invoke it or what the required id should be.

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 there is exactly one parameter, 'id', whose meaning is entirely undocumented in both the schema and the description. The description does not say whether id refers to an agent, a trust record, a certificate, or something else, so the caller cannot know what to pass.

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 is essentially a restatement of the tool name plus a bracketed namespace tag. 'Drift certificate' names a resource but supplies no verb and no indication of what the tool actually does with a drift certificate. It is a tautology rather than a stated purpose.

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 whatsoever about when to call this tool, and no mention of nearby siblings such as drift_check, trust_score, trust_decay, or trust_history. An agent cannot infer when this tool is preferred over those alternatives.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: no cost, permissions, whether it mutates state or merely reports, rate limits, or what happens when the windows don't overlap. The '[trust]' tag and 'DRG-100-DriftBound' code are opaque labels, not behavioral information.

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?

It is short, but its brevity comes from under-specification rather than efficiency — a single fragment that communicates no operation. There is nothing to front-load because nothing substantive is said.

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 a nested-object schema, three required params, no output schema, and no annotations, the description should carry the entire explanatory load. It provides none of it, so the agent cannot construct a valid or meaningful call.

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 three required parameters, two of which are nested objects (reference_window, current_window) with entirely undefined shape. The description adds no meaning to model_id or the window structures, leaving their format, units, and expected keys completely unspecified.

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 says 'DriftGuard check (DRG-100-DriftBound)', which essentially restates the tool name inside a product codename plus an undocumented internal identifier. It never explains what 'drift' means here or what the check measures, so an agent cannot distinguish it from siblings like drift_certificate or agents_semantic_diff.

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, when-not-to-use, or alternative is mentioned. With drift_certificate, trust_decay, trust_score, and agents_semantic_diff in the sibling list, the agent has no basis for choosing drift_check over any of them.

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 usefully discloses the recomputation semantics and a concrete rate limit ('3 free calls/day, then entitlement ledger'), which is genuine behavioral context. But it omits mutation/read profile, failure behavior, and what the result of enforcement looks like.

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?

Front-loads the product/entitlement tag, then the purpose, then the rate limit in a compact three-sentence form with no filler. The entitlement appears twice (bracketed tag and 'then entitlement ledger'), a minor redundancy but the structure remains tight.

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 verification tool with nested input objects, no output schema, and no annotations, the description covers purpose and entitlement but leaves notable gaps: what GREEN means, what enforcement returns, and how it relates to sibling SLA tools. Adequate but not complete for the tool's complexity.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters, making 3 the baseline. The description ties claimed_digest to the verification condition, adding mild meaning, but does not explain the 'inputs' payload structure or the obligation label's role beyond the schema text.

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 (enforce) and resource (SLA/obligation) plus the mechanism: recomputation where the obligation is met only if the work verifies GREEN against its claimed digest. This clearly distinguishes it from a generic SLA tool, though it never names siblings like sla_register or sla_report to route the agent explicitly.

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 verification condition ('GREEN against its claimed digest') implies when this tool applies, and the entitlement/rate-limit note hints at cost constraints. However, there is no explicit when-to-use vs sla_register/sla_report, no prerequisites, and no statement of what to do when work fails 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?

With no annotations, the description carries the full behavioral burden, but it only implies a creation operation. It omits critical traits for a financial escrow tool: whether funds are locked, authorization requirements, reversibility, how the nested 'conditions' object affects release, and any side effects. It provides only the most basic action type.

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 short phrase, not verbose, but it is critically under-specified for the complexity of the operation. Conciseness here reflects under-specification rather than efficiency; no structural elements like clauses or lists help an agent.

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

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

For a complex financial escrow creation tool with 5 parameters, a nested 'conditions' object, no output schema, and no annotations, the description is completely inadequate. It omits prerequisites, behavior on success/failure, return information, and parameter guidance.

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 5 parameters (payer_id, payee_id, amount, currency, conditions), and the description adds no meaning about their formats, roles, or constraints. It does not compensate for the total 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?

States a specific verb ('Create') and resource ('agent-to-agent escrow'), clearly distinguishing it from sibling escrow operations like escrow_release and escrow_dispute. An agent can identify the operation without opening the schema.

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 on when to use this tool versus escrow_release, escrow_dispute, or other defi tools; no prerequisites or exclusions are mentioned. The description merely states the action, leaving the agent to infer 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?

With no annotations and no behavioral detail, the description does not disclose who can open a dispute, what happens after opening one, whether it is reversible, or what permissions are required. For a likely mutation operation on an escrow, this is a complete absence of behavioral context.

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

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

The description is extremely terse, a single phrase plus a domain tag. While concise, it is under-specified for a mutation tool with a required reason and optional nested evidence, so the brevity does not earn its place as useful guidance.

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

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

Given no annotations, no output schema, 0% schema description coverage, and three parameters including a nested evidence object, the description is far too thin to be complete. An agent lacks the context needed to invoke this tool correctly.

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

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

Schema description coverage is 0%, so the description must carry all parameter meaning, but it adds nothing about escrow_id, reason, or the nested evidence object. An agent cannot tell from the description what a valid reason looks like or what evidence should contain.

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 clear action and resource: opening an escrow dispute. The [defi] tag gives domain context, but it does not differentiate from sibling tools such as escrow_create or escrow_release beyond the verb 'dispute'.

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 on when to use this tool versus alternatives like escrow_release or escrow_create, nor are prerequisites or conditions for opening a dispute stated. The description implies a scenario but leaves selection entirely 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?

No annotations are provided, so the description carries the full burden. It implies a mutation of funds but omits critical traits such as authorization requirements, irreversibility, release conditions, and what happens to the escrow state.

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

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

The description is extremely short and front-loaded with a useful domain tag ([defi]). It wastes no words, but the brevity is under-specification rather than efficient completeness for a financial mutation tool.

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

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

For a DeFi fund-release operation, the description is grossly incomplete. With no annotations, no output schema, and 0% parameter coverage, it should convey safety, authorization, and state-change context but provides none.

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 parameter escrow_id has no description. The tool description does not add any meaning about the parameter's format, source, or expected value, failing 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 (release) and resource (escrowed funds), so an agent understands the core action. However, it does not explicitly differentiate from sibling tools such as escrow_create or escrow_dispute beyond the name itself.

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 no when-to-use guidance, no prerequisites, and no alternatives. It merely restates the action without indicating in which scenarios release should be invoked or what conditions must be met.

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, and it discloses nothing: no read vs write behavior, no side effects, no auth or cost requirements, no failure modes. One noun phrase cannot cover a tool's behavioral 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?

It is short, but brevity here reflects under-specification rather than conciseness. There is no front-loaded statement of purpose to structure, so the fragment does not earn its place as a usable 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?

With no annotations, no output schema, and no parameter documentation, the description is the only source of meaning and it provides none. An agent cannot determine what a "badge" is, what {model} refers to, or what to expect back.

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 zero parameters, so there is nothing to document; per the baseline rule a 0-parameter tool starts at 4. The description adds nothing here, but nothing is missing either.

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?

"Model quality badge" names a resource but supplies no verb describing the operation — is this generating, fetching, or checking a badge? The bracketed "[fuse]" prefix adds no discernible meaning. It essentially restates the tool name's noun rather than stating what the 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?

There is no guidance on when to use this tool versus neighbors like forge_verify, forge_leaderboard, forge_quarantine, or forge_delta_submit. No preconditions, no alternatives, and no scenario is described.

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, and it discloses nothing. It does not say whether submission is idempotent, what permissions or signatures it requires, whether the delta is validated/rejected, or what side effects occur on the forge ledger.

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 brief and front-loaded, but this is under-specification rather than conciseness: too little is said for a mutation tool with a nested-object parameter. Brevity here costs correctness.

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 no annotations, no output schema, a nested required 'delta' object, and 0% schema coverage, the description should explain validation, required delta contents, and result behavior. None of that is present, so the definition is not usable on its own.

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 adds no parameter meaning at all. The key 'delta' is a nested object with no documented shape, and 'model_id' and 'description' are unexplained, leaving the agent unable to 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 names a verb ('Submit') and a resource ('model delta'), which is more than a tautology, but '[fuse]' is an opaque prefix and 'model delta' is never defined. It does not distinguish this tool from sibling registration/verification tools such as forge_verify or forge_quarantine, so an agent cannot confidently route to it.

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 tool, what preconditions exist (e.g. must the model already be registered via forge_verify or ratchet_register), or which sibling handles related operations. The description offers nothing about use 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says nothing about whether this is a read-only operation, what the leaderboard ranks on, how it is ordered, or whether results are cached or paginated.

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 words plus an opaque bracket tag are terse, but this is under-specification rather than conciseness. There is no front-loaded statement of what the tool actually does or returns.

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 tool with no output schema and no annotations, the description should still explain what the leaderboard contains, how it is ranked, and when an agent should consult it. None of that is present, so an agent cannot confidently invoke or interpret 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?

The schema declares zero parameters, so there are no parameter semantics to document and the baseline of 4 applies. Nothing in the description is needed to compensate for schema 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 is a bare noun phrase ('Model leaderboard') with a cryptic '[fuse]' tag and no verb, so it only hints at the resource being retrieved. It does not distinguish this from sibling forge_* tools such as forge_verify or forge_delta_submit, leaving the agent to guess the exact action.

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 indication of when to call this tool, what triggers it, or how it relates to the other forge_* siblings. No exclusions, prerequisites, or alternatives are mentioned.

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, and it discloses nothing about side effects, permissions, or mutability. Whether calling this modifies quarantine state is entirely unknown.

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 brevity here is under-specification rather than conciseness: two words plus a tag convey almost nothing actionable. Nothing is front-loaded because there is essentially no content to front-load.

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 no annotations, no output schema, and no parameter documentation, the description is the only signal available and it provides none. For a tool in a dense multi-agent/compliance toolset, this is wholly 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?

The tool takes zero parameters, so per the baseline there is nothing for the description to disambiguate. No syntax or filtering details are needed because the schema is empty.

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?

"[fuse] Quarantined models" names a resource but no verb, so the agent cannot tell whether this lists quarantined models, quarantines a model, or retrieves one. The bracketed tag "fuse" is opaque and does not clarify scope relative to siblings like forge_verify, forge_leaderboard, or forge_delta_submit.

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 guess in an ecosystem with dozens of similarly named forge_/trust_/ratchet_ 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses essentially nothing: no side effects, no mutation semantics, no auth requirements, no failure or rejection behavior, and no indication of whether verification is idempotent or async. Only the weak implication of 'verify' suggests a read-oriented check.

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 text is short, but this is under-specification rather than conciseness: seven words plus a bracketed namespace tag that carries no information for the caller. Nothing is front-loaded beyond a bare verb-resource pair.

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 two-parameter tool with no annotations and no output schema, the description should at minimum explain what verification produces and how verification_type changes the operation. Neither is addressed, so the definition is not sufficient for correct 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 description coverage is 0% for both parameters, and the description never mentions model_id or verification_type. Critically, the agent is given no hint about what values verification_type accepts or what happens when it is omitted, leaving the only non-trivial parameter completely opaque.

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 verb (Verify) and a loosely defined resource (a model submission), which is enough to guess the domain but not the mechanism. It does nothing to distinguish itself from the many sibling verify tools (rng_verify, identity_verify, defi_bridge_verify, verify_settlement), and the '[fuse]' namespace tag adds no usable meaning.

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 statement of when to use this tool, what preconditions are required, or which sibling to prefer for adjacent tasks (e.g., forge_delta_submit, forge_quarantine). The agent must infer all routing 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: no mention of what is evaluated, what verdict or score comes back, whether it consumes credits/rate limits, or what happens on failure. An agent learns only that some undefined check 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?

It is short, but that brevity reflects under-specification rather than economy — a category tag plus a four-word noun phrase with no front-loaded statement of action or outcome. Nothing here earns its place because nothing informative is said.

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 zero parameters and no output schema, the description is the only channel for describing what this tool returns, and it says nothing about the result of the check. For an opaque verdict-style tool in a crowded identity/reputation sibling set, this is a substantial 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?

The schema takes zero parameters, so there is no parameter semantics for the description to clarify and the baseline of 4 applies. However, the absence of required inputs is never acknowledged, leaving unclear whether the subject is supplied by context or a prior 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?

"[identity] Sybil-resistance check" is essentially the tool name restated with a category tag; it names no verb and no resource beyond what the name already conveys. It does not distinguish this tool from the sibling identity_verify or explain what a "Sybil-resistance check" actually inspects or decides.

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 at all — nothing says when this check should be run, on what subject, or why an agent would pick it over identity_verify, trust_score, or agents_reputation. The bracketed "[identity]" tag is a category label, not usable 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states no side effects, no permission requirements, no interpretation of 'topological' verification, and no indication of what the tool returns or changes.

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 very short, but its brevity reflects under-specification rather than effective conciseness. It is front-loaded with a category tag and a vague phrase, offering no useful structure for an agent.

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

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

For a verification tool with one undocumented required parameter, no annotations, and no output schema, the description is completely inadequate. It does not explain the verification process, expected inputs, or outcomes.

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

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

The single required parameter agent_id has 0% schema description coverage and is not mentioned in the description. The description adds no meaning about the parameter's format, source, or expected value beyond the sparse example in the schema.

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

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

The phrase 'Topological identity verification' largely restates the tool name identity_verify with an unexplained modifier. It does not clarify what is being verified, what 'topological' means operationally, or how it differs from identity_sybil_check and other identity/agent 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?

There is no guidance on when to call this tool, what conditions make it appropriate, or which sibling tools might be alternatives. The agent is left to infer usage 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?

With no annotations, the description carries the full behavioral burden, yet 'hallucination guard' is left unexplained — no detail on what the guard does, whether it filters or flags, auth needs, or limits. Only a hint of behavior is conveyed.

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 terse line that is under-specified rather than efficient; it omits the context needed to invoke the tool and reads more like a tag than a usable description.

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 annotations, no output schema, and an undocumented top-level parameter, the description is far too thin. It neither explains the hallucination-guard behavior nor the expected response, leaving core agent questions unanswered.

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

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

The single required 'messages' parameter has no description in the schema (coverage 0%), and the tool description adds nothing about its structure, ordering, or required roles. The nested enum and example help somewhat, but the description contributes no parameter meaning.

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

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

The description names the resource (chat inference) and gestures at a distinguishing feature (hallucination guard), so the general purpose is discernible. However the verb is weak and it does not clearly separate itself from the nearby sibling inference_stream, leaving the agent to infer the difference.

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 statement of when to use this tool, when not to, or which alternative (e.g. inference_stream, rag_augment, oracle_hallucination) to prefer. The agent gets no routing signal at all.

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, and it does disclose one meaningful trait: output is streamed rather than returned whole. Beyond that it is silent – no description of the streaming format (chunks, SSE, deltas), whether the call blocks or is long-running, latency, rate limits, or auth requirements. For a streaming endpoint these are the facts an agent most needs.

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 six-word fragment with zero filler and the key qualifier 'streaming' front-loaded. It is efficiently sized, though it is too terse to function as a real specification rather than a label.

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 no output schema and no annotations, the description must explain the return shape – critical for a streaming tool where the agent needs to know it receives incremental fragments rather than a final string – and it does not. Combined with zero parameter elaboration and no sibling differentiation, it leaves substantial gaps for a tool sitting next to a near-identical 'inference' sibling.

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?

Top-level schema description coverage is 0%, and the single required 'messages' parameter is defined only by the name and by nested role/content descriptions plus an example. The description adds no clarification of message structure, ordering, or the system/user/assistant roles. With coverage this low, the description was expected to compensate and does not.

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 phrase 'Streaming inference with chain-of-thought' names the operation (inference) and its mode (streaming) plus a capability (chain-of-thought), so the general purpose is discernible. However, it never distinguishes itself from the sibling tool 'inference' – an agent cannot tell from the text which of the two to pick or what 'chain-of-thought' adds. It reads more like a category label than a specific tool statement.

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 at all, despite an obvious alternative sibling 'inference' that presumably offers non-streaming behavior. Nothing states the conditions under which streaming is preferred, nor any exclusions or prerequisites. The bracketed '[inference]' prefix only groups the tool; it does not route the agent.

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

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

With no annotations, the description carries the full behavioral burden. It helpfully discloses that the call is free, requires no key, and is idempotent, and it lists returned content, but it does not clarify side effects, whether any state is created or modified, or what happens when agent_id is supplied.

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 front-loaded with 'START HERE' and packs the key facts into a compact paragraph. Some terminology ('Atomadic control surface', 'proves the superpowers') is promotional and could be tighter, but overall it is appropriately sized and 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?

There is no output schema or annotations, so the description does most of the explanatory work. It lists the main return items and notes that the call is free, keyless, and idempotent, which is enough for an agent to invoke it correctly, though it leaves the exact 'control surface' concept and state effects vague.

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

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

Schema description coverage is 100%, and the single optional agent_id parameter is fully documented in the schema. The description adds no additional meaning about how agent_id affects onboarding tracking, so the baseline of 3 is appropriate.

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

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

The description states a specific action ('Initialize your Atomadic control surface') and enumerates what the call returns (setup steps, runnable demo, recon links, bootstrap). It is clearly an onboarding entry point, though the term 'Atomadic control surface' is opaque and it does not explicitly name or contrast with any sibling tool.

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

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

The opening 'START HERE' gives strong contextual guidance for when to use the tool, and 'Idempotent — re-call anytime to re-check' clarifies repeat usage. It does not provide when-not-to-use conditions or name alternatives, but 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?

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about whether this is a read or write, what an "epoch" means here, latency, determinism, or side effects. Saying it is an "oracle" implies retrieval but supplies zero operational detail.

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

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

Five words is technically concise, but this is under-specification rather than conciseness — no sentence earns its place because no information is conveyed beyond the name. The bracket tag is the only structural element.

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 no annotations, no output schema, and no parameters, the description is the only source of information about this tool, and it provides none. An agent cannot know what the call returns, when it is appropriate, or how it differs from the other oracle and RNG siblings.

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 takes zero parameters, so per the baseline there is nothing for the description to document. The schema is fully (vacuously) covered at 100%. No parameter-level value is expected or missing.

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?

"Entropy epoch oracle" is a noun phrase that essentially restates the tool name, oracle_entropy. There is no verb indicating whether it retrieves, generates, or verifies entropy, and it is not distinguished from siblings like rng_quantum, rng_verify, defi_oracle_verify, or oracle_hallucination.

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, no prerequisites, and no mention of any alternative. An agent has no basis for choosing this over the several other oracle/RNG tools in the sibling list. The "[trust]" prefix is a tag, not usage 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not what a 'hallucination' verdict means, whether the result is probabilistic or deterministic, whether an external model/knowledge source is involved, or any latency/cost/auth profile. The single tag '[trust]' conveys no 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?

It is short, but this is under-specification rather than conciseness — there is no front-loaded statement of purpose, inputs, or outcome for the reader to anchor on.

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 2-parameter tool with no annotations, no output schema, and 0% schema coverage, the description should at minimum state what it returns and how 'claim'/'context' are interpreted. None of that is present, leaving the agent unable to use it reliably.

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 would need to explain 'claim' and 'context'; it says nothing. The schema's inline examples ('Water boils at 100°C at sea level', 'physics') hint at intent, but there is no statement of whether context is a domain label, expected answer, or free-text framing.

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 is essentially a restatement of the tool name: 'oracle_hallucination' → 'Hallucination oracle.' The '[trust]' prefix is a category tag, not a clarifying verb or scope statement. It does not distinguish this from siblings such as detect_contradiction, agents_contradiction, defi_oracle_verify, or inference.

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 whatsoever on when to use this tool, when not to, or which sibling to prefer for fact/claim verification. An agent must guess 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?

No annotations are provided, so the description must carry the full behavioral burden. It offers only the adjective 'Trusted' and says nothing about permissions, side effects, data flow, reversion, rate limits, or any other behavioral trait an agent would need.

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 phrase, not a sentence, and is under-specified rather than concise. It fails to front-load any meaningful information, so brevity here is a defect, not a virtue.

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 no annotations, no output schema, and no parameter schema, the description is the only source of information about this tool, and it provides none. An agent cannot confidently select or invoke this tool based on such a sparse definition.

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 there are no parameters to document. According to the evaluation rules, 0 params establishes a baseline of 4; the description neither adds nor detracts from that 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 'Trusted RAG augmentation' restates the tool name 'rag_augment' without adding a specific verb or clarifying what the augmentation does or what it operates on. It is essentially a tautology, and the vague 'Trusted' qualifier does not distinguish it from any sibling tool.

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

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

There is no indication of when to use this tool versus alternatives, no prerequisites, and no exclusions. The description provides no usage context whatsoever.

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 and fails it. It does not state that this is a state-mutating operation, whether the advance is reversible, what preconditions (registered/probed session) apply, or what happens on an invalid session_id. "Advance" weakly implies forward-only progress, which is the only behavioral signal present.

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 text is short, but shortness here reflects under-specification rather than economy. It also contains a stray "[identity]" tag and mojibake ("—"), which are noise rather than signal and make the definition harder to parse. Nothing meaningful is front-loaded because almost nothing is said.

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 no annotations, no output schema, no parameter documentation, and a mutating session operation in a large tool family, the definition supplies none of the context needed to invoke it safely. An agent would have to guess at preconditions, side effects, and return behavior. It is inadequate for the tool's apparent complexity.

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

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

There is one parameter at 0% schema description coverage, so the description must compensate and does not mention session_id at all. The schema only supplies an example value ("sess-001"), with no indication of where the id comes from or what format it takes beyond the example. A passing baseline does not apply because the single parameter is entirely undocumented.

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 phrase "advance session" gives a concrete verb and resource, and "RatchetGate" hints at the subsystem, so it is not a pure restatement of the name. However, it never says what advancing does to a session (move to the next stage? increment a counter? commit a step?), leaving the core purpose only half-specified. It is distinguishable from siblings only because their names differ, not because the description draws a line.

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 given at all, and no alternative is named despite close siblings ratchet_register and ratchet_probe existing in the same family. An agent cannot tell from the text whether registration or probing must precede an advance, or when this tool is the wrong choice. This is the weakest possible state short of misleading 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not whether the probe is read-only, what it checks (liveness, readiness, gate state), whether it has side effects, or whether it requires authentication.

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?

It is short, but this is under-specification rather than conciseness — the single fragment carries no usable information. The '[identity]' tag and the truncated '—' artifact add noise without meaning.

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

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

With no annotations and no output schema, the description must explain what a health probe returns or signifies, and it does not. Even for a zero-parameter tool, an agent cannot tell what calling it accomplishes or how to 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?

The tool takes zero parameters and the schema is empty, so there is nothing for the description to clarify about inputs. Baseline 4 applies per the 0-param rule.

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 'RatchetGate — health probe' only restates the tool name (ratchet_probe) with a product label. It does not specify what is probed, what a result means, or how it differs from siblings like ratchet_advance, ratchet_register, or drift_check.

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 at all — no context, no prerequisites, no named alternative. An agent has no basis to decide whether to call this versus any other ratchet or health-related sibling.

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, and it discloses nothing. It does not say whether registration is idempotent, whether it creates or mutates state, what happens if the session already exists, or what auth is required.

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?

It is short and technically front-loaded, but this is under-specification rather than conciseness. The single fragment carries no actionable content, so brevity does not earn its place here.

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 no annotations, no output schema, 0% parameter coverage, and a one-line description, an agent has essentially nothing to reason about: no side effects, no return behavior, no failure modes, no context on what a 'session' is in this system.

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 for the single session_id parameter, and it offers nothing beyond the parameter name. The only aid is the self-describing name and the 'sess-001' example in the schema, which the description does not build on (no format, source, or lifecycle meaning).

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

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

The description is essentially a restatement of the tool name: 'ratchet_register' becomes 'register session', with '[identity] RatchetGate' acting as a category tag. It does not state what registering a session accomplishes or how it differs from ratchet_advance or ratchet_probe. This is close to tautology rather than a specific verb+resource statement.

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 indication of when this tool should be used, what preconditions exist, or which sibling tool is the alternative. With ratchet_advance and ratchet_probe sitting alongside it, the absence of any routing guidance leaves the agent unable to choose correctly.

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 and does add real behavioral context: the deterministic verified-minus-refuted computation, the rejection of LLM judgment, and a concrete rate limit (3 free calls/day) with an entitlement gate. It still omits the return shape and what happens when receipts are malformed or empty, so the disclosure is useful but incomplete.

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?

Compact and front-loaded: purpose first, then the deterministic clarification, then quota/entitlement. The bracketed '[Ledger product, entitlement: ledger]' prefix is slightly awkward and partially duplicates the later entitlement mention, but overall the text is 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?

For a one-parameter tool with no output schema, the description covers the computation, determinism, and quota, which is the essential context. It does not describe the return value or error behavior, which an agent would need since no output schema exists to fill that 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 description coverage is 100%, so the single 'receipts' parameter and its 'ok'/'score' fields are already documented. The description's 'verified minus refuted' hints at how 'ok' is consumed but adds no new syntactic or semantic detail beyond the schema. Baseline 3 applies.

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 and resource ('Compute an agent's reputation from a ledger of verifiable receipts') and even specifies the algorithm ('verified minus refuted') and its deterministic nature. It does not, however, distinguish itself from close siblings like agents_reputation, reputation_record, or trust_score, leaving the agent to infer which reputation tool applies.

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 only guidance offered is pricing/quota ('3 free calls/day, then entitlement ledger'), which tells the agent about cost but not when to choose this tool over agents_reputation or trust_score. No when-to-use, when-not-to-use, or alternative routing is provided.

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 discloses two useful traits: the return shape ({ok, ir, results, languages}) and the constraint that only baked-in canonical examples work here while novel inputs require the SDK. It still omits error behavior, entitlement enforcement details, and any auth/rate-limit context, so it is only partially transparent for a demo-gated 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?

Three short sentences. The core capability statement comes after a bracketed metadata prefix ('Fuse product · entitlement...'), which is slightly front-loaded with non-behavioral noise, but the body is dense and mostly waste-free.

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 annotations, no output schema, and 0% parameter documentation, the description should do more heavy lifting. It explains the return keys and the demo restriction, but leaves both required parameters and error/entitlement behavior unexplained, so an agent still cannot confidently construct a valid call.

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 both parameter descriptions are empty, so the description must compensate. It does not mention source_text or atom_name at all – not the expected format of source_text nor the role of atom_name. The only clue is that 'novel inputs via SDK', implying source_text must match baked examples, which is thin.

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 gives a specific verb and scope: 'Polyglot emit to all 7 supported targets in one call.' That distinguishes it from the similarly named sibling render_polyglot_roundtrip_pure by emphasizing it emits to all targets rather than a roundtrip. The '7 supported targets' and return keys make the purpose concrete, though the jargon 'polyglot emit' and the bracket metadata add noise.

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 hints at a usage boundary – canonical demo examples work via R2 while 'novel inputs via SDK' – which implies when this tool applies and when it doesn't. However, there is no explicit when-to-use guidance relative to the sibling render_polyglot_roundtrip_pure, so the routing is only implied.

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 does add real behavioral context: entitlement gating ('fuse', 'FREE_R2_DEMO'), pre-baked demo coverage (4 examples × 12 languages), and live emit of novel inputs via the SDK. But it omits failure modes, whether novel inputs require the SDK entitlement, and any auth or rate-limit 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?

It is a single dense sentence, which is structurally front-loaded, but the promotional product tag and entitlement prefix consume the opening without informing invocation. Jargon ('render head', 'Syntax-as-Data') adds length without adding actionable meaning.

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

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

No output schema, no annotations, and 0% parameter coverage mean the description should be doing far more. It gives no return-value expectations for a translation tool and does not document the required atom_name, so an agent cannot confidently construct a call.

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 all three parameters, so the description must compensate, and it only partially does. 'source' and 'target language' loosely map to source_text and language, but the required parameter atom_name is never explained, leaving a mandatory input semantically opaque.

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 does identify a transform verb and resource ('polyglot render head: source -> language-neutral logic IR -> source in target language'), which conveys the translation pipeline. However 'render head' is internal jargon, and the leading '[Fuse product · entitlement: fuse · FREE_R2_DEMO]' marketing tag dilutes the actual purpose. It never distinguishes itself from the sibling render_polyglot_all_pure.

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, when-not-to-use, or alternative routing is given. The presence of a near-identical sibling (render_polyglot_all_pure) makes this omission especially costly, since the agent has no basis to choose between 'roundtrip' and 'all'. The R2/SDK sentences describe internals rather than selection criteria.

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

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

No annotations are provided, so the description carries the full burden. It implies a write ("Record") but says nothing about whether the record is append-only or mutable, whether it updates a reputation score, whether it requires prior agent registration, or whether it is idempotent. For a state-mutating reputation tool this is a substantial gap.

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?

It is short, but brevity here reflects under-specification rather than tight writing. A single fragment cannot front-load the information an agent needs, so there is no structure to evaluate beyond its minimal length.

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 4-parameter, 3-required mutation tool with no annotations, no output schema, and 0% schema description coverage, the description is far too thin. An agent has no way to know required input formats or the side effects of recording an interaction, though the terse purpose statement at least prevents total 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% and the description mentions no parameters at all. Three of four parameters are required (agent_id, interaction_type, outcome) and one has an enum, yet the description adds zero meaning about expected formats, valid interaction_type values, or the optional counterparty_id.

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 gives a verb and a resource ("Record agent interaction"), so the basic operation is identifiable. However, it never clarifies what an "interaction" is in this system, what recording it does to reputation state, or how it differs from siblings like agents_reputation, receipt_reputation, or trust_history, leaving the purpose only loosely pinned down.

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 reference to any alternative tool. The only contextual cue is the bracketed "[agents]" tag, which hints at scope but does not tell an agent when this call is appropriate versus the many other agent- and trust-related 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?

No annotations at all, so the description carries the full burden. 'With proof' is a faint hint that the response includes a verifiable artifact, but nothing is said about the randomness source, whether results are reproducible, cost/latency, or what 'proof' concretely is — the one behavioral claim is unexplained.

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 line with no waste, but it reads as under-specification rather than deliberate brevity — the '[inference]' tag consumes space without adding information an agent can act on.

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 no annotations, no output schema, and no parameters to lean on, the description is the only source of behavior — and it leaves the nature of the returned 'proof' and its relation to rng_verify completely undefined. For a tool whose main value proposition is the proof artifact, that is a real 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?

Zero parameters and an empty, fully-covered schema, so there is nothing for the description to disambiguate. Baseline 4 applies.

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?

Identifies the resource ('Quantum random number') and a distinguishing attribute ('with proof'), so an agent can roughly tell it apart from rng_verify. But no verb states the action — generate? fetch? — and the bracketed '[inference]' prefix is unexplained noise that could confuse rather than clarify.

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, no conditions, and no mention of the obvious sibling rng_verify, which presumably validates the proof this tool produces. The agent is left to infer the relationship between the two from names 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?

No annotations are provided, so the description carries the full disclosure burden and delivers almost nothing: no statement of permissions, whether verification is local or networked, whether it fails loudly on mismatch, or what a result looks like. The '[inference]' prefix hints at execution class but is unexplained.

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 short phrase, front-loaded with the verb. It is efficient, though the unexplained '[inference]' tag consumes space without conveying usable meaning to an agent.

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

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

With no output schema and no annotations, the description should explain what the verification returns (boolean, proof, status) and against what reference the epoch value is checked. Neither is present, leaving a caller unable to 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?

The tool takes zero parameters, so the baseline is 4. The description correctly implies no caller-supplied inputs, though it does not explain why no epoch identifier or proof argument is needed.

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 and resource: 'Verify' plus 'current epoch random value'. The agent can identify the operation, but the description does not distinguish it from nearby siblings such as rng_quantum or oracle_entropy, nor does it clarify what 'verify' checks against.

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 named alternative. In a cluster of rng/oracle/verify tools (rng_quantum, oracle_entropy, defi_oracle_verify), the agent is left to guess which one applies.

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 usefully discloses a quota (3 free calls/day) and an entitlement gate ('ledger'), which is real behavioral context an agent should know before invoking. It says nothing about side effects, idempotency, latency, or whether the routing is purely advisory, so disclosure is partial.

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 short sentences with no filler; the product/entitlement tag is front-loaded and the core action follows. Nothing is redundant, though the bracketed metadata prefix adds minor noise before the actual purpose statement.

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 tool with no output schema and no annotations, the description should at minimum describe what a successful call returns. It says the result is a 'capability/pipeline coordinate' but never explains the shape or how to use that coordinate, leaving a meaningful 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?

Only one parameter, fully documented in the schema (100% coverage: 'The natural-language intent to route'). The description adds no syntax, format, or example beyond what the schema already states, so baseline 3 is appropriate.

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

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

States a specific verb and resource: 'Route a natural-language intent to a deterministic capability/pipeline coordinate.' An agent understands this is intent-to-route resolution, not text processing. However, it does not distinguish itself from plausible siblings like agents_intent_classify or inference, so the agent must guess which routing tool is canonical.

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, when-not-to-use, or alternative is named. The only usage constraint given is a quota ('3 free calls/day, then entitlement ledger'), which is a rate/pricing limit rather than guidance on selecting this tool over its many 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: not whether the call is read-only or mutating, not whether it is expensive/long-running, not what happens on failure. The only signal is the implied read-like nature of an "assessment," which is weak.

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?

It is short, but brevity here reflects under-specification rather than tight structure. There is a single fragment with no front-loaded statement of action, scope, or result.

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 security-domain tool with a nested-object parameter, no output schema, and zero annotation coverage, the description omits everything an agent needs: input format, expected return, and behavioral characteristics. This is effectively a label rather than a definition.

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% for two parameters, including a nested "context" object, and the description explains neither. It gives no hint whether "target" is a domain, IP, package name, or hash, so the agent must guess the required input format.

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?

"[security] Zero-day threat assessment" is a noun phrase that restates the tool name with a category tag; it contains no verb describing what the tool actually does (scan, query, classify, report). An agent cannot tell whether it evaluates a target, retrieves a stored assessment, or triggers a scan.

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 alternatives — notably the sibling threat_score, which plausibly overlaps. Nothing in the description routes the agent between them.

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 provided, the description carries the full behavioral burden and delivers nothing. It does not state whether registration is idempotent, what side effects or state it creates, what permissions are required, or how a registered SLA relates to enforcement.

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 short sentence is front-loaded and not padded, but its brevity here reflects under-specification rather than economy. A tool with three required parameters and a nested object cannot be adequately conveyed in four words.

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

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

For a write/registration tool with three required params, a nested object, no annotations, and no output schema, the description is completely inadequate. Nothing an agent needs to call this correctly is present.

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 supplies no parameter meaning at all. Most critically, the nested "terms" object has no documented structure anywhere, so the agent cannot know what an SLA definition must contain.

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?

"Register an SLA" gives a verb (register) and a resource (SLA), so the basic action is inferable. However, the bracketed "[agents]" prefix is cryptic and the description does nothing to separate this from siblings like enforce_sla or sla_report. It is minimally viable but not specific about what registering an SLA actually establishes.

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 versus enforce_sla or sla_report, no prerequisites, and no stated context. The agent is left to infer the lifecycle positioning entirely 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, and it discloses nothing. It does not say whether reporting is idempotent, whether it mutates state or only notifies, what permissions are required, or what happens after a report is filed.

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?

It is short and front-loaded, but this is under-specification rather than conciseness: a four-word fragment plus a bracketed namespace tag leaves the essential call semantics unstated. Brevity here costs the agent more than it saves.

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 three-parameter tool with two required parameters, no annotations, no output schema, and zero parameter documentation is not adequately described. An agent cannot reliably populate violation_type or predict the effect of the call from this definition.

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

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

All three parameters (sla_id, description, violation_type) have 0% schema description coverage, and the description mentions none of them. Key semantics an agent needs — the accepted values of violation_type, and whether description is required in practice — appear nowhere.

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 gives a verb and resource ("Report ... SLA violation"), so the basic action is identifiable. However, "report" is ambiguous — it could mean filing a violation record, notifying a party, or emitting a report — and the bracketed "[agents]" prefix is namespace noise rather than meaning. Nothing distinguishes it from the closely named siblings sla_register and enforce_sla.

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 routing to alternatives. With sla_register and enforce_sla in the sibling list, the boundary between registering an SLA, enforcing one, and reporting a violation is left entirely 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?

With no annotations, the description carries the full behavioral burden. 'Poll' weakly implies a read operation, but it does not disclose whether polling consumes messages, blocks, requires authentication, has rate limits, or what side effects occur. This is far too thin for a tool with zero structured behavioral hints.

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

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

The description is extremely concise with no wasted words and is front-loaded. The bracket prefix '[agents]' may be a category tag, but overall structure is efficient for a parameterless tool.

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

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

Given no annotations, no output schema, and no parameters, the description should explain what polling returns (e.g., message list, blocking behavior, pagination) to be complete. It says nothing beyond the bare action, leaving a significant gap for an agent to call 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 tool takes zero parameters, so there is nothing to document and the schema cannot be deficient. The description therefore does not need to compensate for parameter gaps; baseline 4 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?

States a specific verb (Poll) and resource (swarm inbox), making the tool's basic action clear. However, it offers no scope details or differentiation from related siblings like swarm_relay, so an agent must infer whether this is a read-only check or something more.

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 no guidance on when to use this tool versus any alternative, no preconditions, and no exclusions. It is essentially a bare label with zero usage 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?

With no annotations, the description carries the full behavioral burden, yet it discloses nothing about delivery semantics, what happens if target_agent_id is unknown, whether relay is synchronous, or error behavior. A routing/mutation tool with zero annotation coverage needs far more.

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 phrase is front-loaded and free of waste, but it is under-specified rather than genuinely concise; the brevity comes at the cost of any actionable detail.

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 3-parameter tool with a nested object payload, no annotations, and no output schema, the description is inadequate — it omits routing behavior, delivery/failure semantics, and message structure expectations.

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 only 33% — only ttl is documented ('Hop limit for relay'), while target_agent_id and the nested message object are undocumented. The description adds no parameter meaning to compensate, leaving the nested message structure entirely opaque.

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 clear verb+resource ('Relay message') and a scope ('through swarm'), and is distinguishable from the receive-oriented sibling swarm_inbox. However, it does not explicitly name or contrast with any sibling, so it falls 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?

There is no when-to-use guidance, no preconditions, and no mention of alternatives such as swarm_inbox for the reverse direction or agents_plan for coordination. The agent must infer usage 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?

No annotations are provided, so the description carries the full burden. It only offers a category tag '[inference]' and the task name; it does not disclose determinism, rate limits, output format, or whether max_keywords is a hard limit, leaving behavioral traits entirely opaque.

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 fragment, which is concise but under-specified. It is front-loaded but lacks any structure that would help an agent understand scope or behavior.

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 no annotations, no output schema, and 0% parameter coverage, the description is far too sparse. It omits return format, keyword selection criteria, and how max_keywords affects output, leaving critical gaps for 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% and the description adds no information about the two parameters (text, max_keywords). It does not explain what max_keywords does, its default, or accepted range, so it fails to compensate for the schema 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 'Keyword extraction' – a specific task on text, distinct from siblings like text_sentiment and text_summarize. However, it lacks an explicit verb and does not name alternatives, so it is clear but not fully differentiated.

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 on when to use this tool versus text_summarize or text_sentiment, nor any exclusions or prerequisites. The name implies a use case, but the description provides no explicit 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?

No annotations are provided, so the description must convey behavioral traits. It says only 'Sentiment analysis', omitting output format (score vs label), supported languages, performance, or any side effects. It provides no behavioral 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?

The description is extremely short (two words plus a bracket) and under-specified rather than concise. It omits necessary information while the '[inference]' prefix does not earn its place.

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

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

Given a simple tool with one input and no output schema, the description is incomplete: it does not describe what the tool returns (e.g., sentiment label, score, or confidence), nor how to interpret results. With no annotations and no output schema, the description should do more.

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 parameter 'text' has only an example in the schema. The description does not mention the parameter or add any meaning. The parameter is trivial and the example gives minimal semantics, but the description fails to compensate for the low 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?

Description is essentially a restatement of the tool name, 'text_sentiment' -> 'Sentiment analysis'. It does not specify the operation or distinguish from sibling tools like text_summarize or inference. The '[inference]' prefix adds no clarifying value.

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 on when to use this tool versus alternatives such as text_summarize or generic inference, nor any prerequisites or exclusions. The description gives no context 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?

No annotations are provided, so the description carries the full behavioral burden. The "[inference]" tag hints that this is a model-inference call (implying cost/latency), but nothing states summary length, style (extractive vs abstractive), language handling, or what the caller receives back. For a zero-annotation tool this is a significant gap.

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 short fragment with no wasted words and no burying of key information. It is under-specified rather than poorly structured, which keeps it from a higher score but also avoids bloat.

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 tool the burden is modest, but with no output schema the description should at least indicate the form of the returned summary (length, format, single vs multi-paragraph). It says nothing about inputs or outputs beyond the tool's name.

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 is one parameter (text) with 0% schema description coverage, and the description adds nothing about it — no size limits, language expectations, or formatting notes. The schema provides only an example string, so the description 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?

"[inference] Text summarization" identifies the resource (text) and the operation (summarize), so an agent can guess the basic intent. However, it largely restates the tool name and offers no differentiation from the nearby text_keywords and text_sentiment siblings. Purpose is inferable but not sharpened.

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 on when to use this versus alternatives such as text_keywords, text_sentiment, or rag_augment, and no mention of prerequisites or context. The agent is left to infer usage entirely 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 must carry the full behavioral burden, but it says nothing about whether the tool reads or mutates state, what permissions are required, what the score represents, or what is returned.

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 short and front-loaded, but it is severely under-specified rather than concise. For a tool with undocumented parameters and no annotations, a four-word phrase does not earn its place as sufficient documentation.

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