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 state transition and the precondition of an approved decision, but it omits permissions, reversibility, side effects, and failure behavior.

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

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

The description is a single front-loaded sentence with no filler. For a four-parameter mutation tool, however, it is arguably too terse to be fully appropriate, even though it is structurally efficient.

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

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

An output schema exists, so return values need not be described. But with no annotations and 0% schema description coverage across four parameters, the description leaves critical invocation details—especially parameter roles and behavioral constraints—unaddressed.

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

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

Schema description coverage is 0% across four parameters. The description implies that an approved ACCEPT_SLICE decision relates to approval_id and that the state transition relates to slice_id, but it never names or explains turn_id or accepted_by, so parameter meaning remains mostly 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 states a specific operation: moving a slice from VERIFIED to ACCEPTED using an approved ACCEPT_SLICE decision. This is clear for the domain, though it does not explicitly mention the resource (slice) or differentiate from siblings like verify_slice or reject_override.

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

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

It implies when to use the tool by naming the required source state (VERIFIED) and the required decision type (trusted approved ACCEPT_SLICE). However, it offers no explicit when-not guidance or alternatives to consider, leaving routing to inference.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses a meaningful precondition: approval must originate from the owner runtime capability, and actor strings are not enough. It does not state side effects, reversibility, or what happens on approval, but it does add real operational context beyond the tool name.

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 only one sentence with no filler, and the key verb 'Approve' is front-loaded. It is appropriately compact, though the brevity contributes to the gaps in parameter and usage 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 an action tool with four parameters, no annotations, and multiple sibling approval/rejection tools, the description is too thin: it omits how approval_id, decision_ref, and approval_token are used, what 'owner runtime capability' means, and when to prefer this over reject_override or request_override. The presence of an output schema covers return values, but the invocation semantics remain under-specified.

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

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

Schema description coverage is 0%, so the description should compensate, but it explains none of the four parameters: approval_id, decided_by, decision_ref, or approval_token. The warning about actor strings being insufficient may relate to decided_by, but it does not clarify any parameter's meaning, format, or requirements.

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

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

The description opens with a specific verb ('Approve') and the tool name supplies the object ('override'), so the core action is identifiable. It also adds a distinguishing constraint: approval must use the owner runtime capability, not actor strings. However, it never explains what an override approval entails or names the closest sibling alternatives, 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?

The description implies when to use this tool by stating that actor strings alone are insufficient and that the owner runtime capability is required, which is a form of usage guidance. It does not explicitly say when to choose approve_override over reject_override, request_override, or list_approvals, and offers no exclusions.

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

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

With no annotations, the description carries the full burden and does real work: it discloses the non-persistence guarantee and explicitly bounds the output's authority ('never grants truth, Evidence, assurance, verification or mutation authority'). It does not cover auth requirements or the meaning of high_impact/review_confidence, but the side-effect and authority boundaries are unusually well stated.

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, front-loaded with the core action and scope, followed by usage then the authority disclaimer. No filler; each sentence adds a distinct layer.

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

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

An output schema exists, so return values need not be described, and the conceptual boundaries are covered well. However, for a 7-parameter tool with no annotations and zero schema descriptions, the complete absence of parameter-level guidance leaves 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?

Schema description coverage is 0% across 7 parameters, so the description is the only source of parameter meaning — and it explains none of them. The BOOL/SCORE/CHOICE mention loosely hints at the shape of `decisions`, but purpose, source, model_ref, high_impact, review_confidence and use_signal_confidence are entirely undefined.

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 pair (validate and gate) on a specific resource (provider-neutral typed fast judgments), and the qualifier 'without persisting them' sharply distinguishes it from the sibling record_fast_judgment. It stops short of naming that sibling, so the agent must infer the routing from the phrase alone.

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?

'Use for cheap BOOL/SCORE/CHOICE signals such as routing, triage, relevance or activation' gives concrete context for when the tool applies. There is no explicit when-not guidance or named alternative (e.g. record_fast_judgment for persistence), which is the only gap.

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

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

The description discloses a key behavioral trait: the operation registers without changing external storage, which helps an agent understand it is metadata-only and not a file-moving or storage-mutating action. However, with no annotations, the description still leaves gaps around idempotency, error behavior, checksum validation, and permissions.

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, focused sentence with no filler; it front-loads the core purpose. It is concise and easy to parse, though its brevity does not allow room for sibling differentiation or usage 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 seven parameters, no annotations, no schema descriptions, and a large set of sibling tools, the description is too sparse for an agent to confidently select and correctly invoke the tool. The output schema reduces the need to describe return values, but key context about when to use this versus registers, models, or links is missing.

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

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

Schema description coverage is 0%, so the description must compensate for the schema's lack of parameter explanations. The description does not define or clarify any of the seven parameters, leaving the agent to infer meaning from names like logical_name, physical_location, and belongs_to without details on formats, constraints, or relationships.

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

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

The description clearly identifies the action ('Register') and the resource ('a physical artifact/reference'), and adds a meaningful qualifier ('without changing its external storage'). However, it does not explicitly distinguish itself from sibling tools like register_contract or register_model, so the differentiation is left to inference from the resource type.

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

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

No guidance is provided about when to use this tool versus alternatives such as register_contract, register_model, link_entities, or record_execution_receipt. The description gives a general sense of the operation but no conditions, exclusions, or explicit scenarios.

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 discloses one important trait—'The capability is never persisted'—but does not explain side effects, whether the attestation record is stored, what permissions are needed, or any failure modes. This is insufficient for a mutation-like operation with no annotation 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?

Two short sentences with no filler. The primary action is front-loaded, and the key non-persistence trait is stated immediately afterward. 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?

Although an output schema exists, the tool still lacks usage guidance, parameter semantics, and behavioral side-effect information. For a 4-parameter tool with no annotations and no schema descriptions, this definition is not complete enough for an agent to invoke 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 must compensate, but it only vaguely references the capability concept and persistence. It gives some context for capability_token and authority, but says nothing about evidence_id or attested_by, leaving most parameter semantics unexplained.

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

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

The description states a clear action ('Attest evidence') and a specific resource, and adds a mechanism ('runtime verifier/owner capability'). It is not a tautology and is understandable on its own, though it does not explicitly differentiate itself from sibling evidence-related tools like submit_evidence or verify_slice.

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

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

No guidance is given about when to use this tool versus alternatives such as submit_evidence, verify_slice, or evidence_freshness. The description implies attestation is a distinct operation, but it never states conditions, prerequisites, or exclusions, leaving the agent to guess.

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 present, the description carries the full burden, and it discloses almost nothing: 'Return' implies a read, but there is no statement about auth/permission requirements, whether the audit_id must reference an open audit, freshness, or error behavior. The opaque 'PCH working-set support' phrase adds no usable 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?

A single front-loaded sentence with no filler or redundancy, which is appropriately sized for a one-parameter read tool. It is efficient even if the phrasing is jargon-dense.

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

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

An output schema exists, so return values need not be spelled out, and it is only a one-parameter tool. Still, the description leaves the audit_id undefined and the enumerated concepts largely uninterpretable, so an agent has minimum-viable but incomplete footing.

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 never mentions the single required audit_id parameter, so it does not compensate for the gap. It offers no format, source, or constraint guidance for the identifier.

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 (Return) and enumerates the resources surfaced (audit frontier, findings, assumptions, mutation boundary, PCH working-set), so the general purpose is discernible. However, the enumerated items are opaque domain jargon and the description does nothing to distinguish this from siblings like audit_status or audit_mutation_allowed.

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 versus the many sibling audit tools (start_scoped_audit, audit_status, record_audit_finding, close_scoped_audit). No prerequisites, no alternatives, no triggering context are given.

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 usefully discloses that this is not an authorization grant and does not replace host permissions, but it does not confirm whether the operation is read-only, whether it has side effects, or what authority is required to call it.

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, front-loaded, and contains no filler. Both sentences serve a purpose, though the extreme brevity contributes to the parameter and usage gaps noted elsewhere.

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

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

An output schema exists, so return values need not be explained. Still, for a tool with three undocumented parameters, no annotations, and a complex audit/permissions domain, the description is too thin: it omits parameter semantics and has only a bare disclaimer about usage.

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

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

There are three parameters with 0% schema description coverage, and the description says nothing about audit_id, ref, or entity_id. The meaning and format of each parameter must be inferred entirely from the schema titles, which is insufficient.

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

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

The description gives a specific verb ('Check') and a domain resource ('the audit's frozen mutation boundary'), but 'frozen mutation boundary' is jargon that does not clearly explain what is returned or how it differs from audit_status/audit_context. It is more concrete than a tautology, but still leaves the core purpose partially inferential.

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 second sentence clarifies that this does not replace normal Plan/WorkTurn or host permissions, which gives a usage caveat. However, it provides no explicit when-to-use condition or comparison to any of the many sibling tools, leaving alternatives and invocation context unstated.

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. It implies a safe read by saying 'Return', but never explicitly states it is non-mutating, what permissions are needed, or how audit_id scoping affects the result. For a status tool with zero annotation coverage this is thin, though the output schema does cover the return shape.

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

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

A single front-loaded sentence with no wasted words; the core action and subject lead. Density of domain terminology slightly reduces readability but there is no filler.

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

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

An output schema exists, so return values are covered, but the two undocumented parameters and the absence of any usage/routing guidance leave the definition incomplete for a tool sitting among many *_status 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?

Schema description coverage is 0% and the description mentions neither audit_id (required) nor frontier_limit (with default 16). Nothing in the prose compensates, so an agent learns nothing about either parameter's meaning or the role of frontier_limit.

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 (Return) and resource (SRA/1 progress and impact-closure fixpoint/boundary status), which reads as a read-only status query. The jargon ('SRA/1', 'impact closure', 'configured boundary') is domain-specific and opaque, but the purpose is discernible and distinct from mutation siblings like start_scoped_audit/close_scoped_audit.

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 call this versus alternatives such as audit_context, audit_mutation_allowed, or the other *_status tools. The agent is left to infer that a progress/fixpoint report is what it wants, with no stated preconditions or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal important constraints: it is a persisted record, the host must refuse dispatch when 'authorized' is false, and high-cost workers require explicit owner approval with a limit of one active per family. However, it omits details about error handling, idempotency, or what happens when constraints are violated. The description gives some context but not a complete behavioral picture.

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

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

The description is concise, consisting of two short paragraphs. The main purpose is front-loaded in the first sentence, and the second paragraph adds relevant context about constraints. There is no wasted wording, and it is appropriately sized for the tool's complexity.

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

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

Given the tool's complexity (9 parameters, 5 required) and the absence of schema descriptions, the description is insufficient. It does not explain what each parameter does, how they relate to the runtime/cost/concurrency state mentioned, or what the output schema contains. The description provides some high-level policy context but leaves an agent without enough information to correctly construct a valid request. For a tool with this many parameters, a much more thorough explanation is needed.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters. It does not. The only parameter-related hint is that high-cost workers require owner approval, which loosely maps to 'cost_ceiling' and 'owner_approval_id', but the description does not explicitly tie these to parameters. Parameters like 'family_id', 'worker_key', 'task_key', 'purpose', 'input_scope', and 'required_capabilities' are left entirely unexplained. The description adds minimal semantic value 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 clearly states the action: 'Persist one bounded delegation authorization from current runtime/cost/concurrency state.' It specifies the resource (delegation authorization) and the verb (persist), and clarifies that this is a policy/coordination record rather than the model dispatch itself, distinguishing it from dispatch-related siblings. However, it does not explicitly name any sibling tool, so it lacks the strongest form of differentiation.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives. It implies its use for creating authorizations but does not contrast with other delegation-related tools like 'complete_delegation' or 'delegation_status'. The statement 'This is a policy/coordination record, not the model dispatch itself' hints at usage but is not a clear directive. No when-to-use or when-not-to-use conditions are given.

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. It implies a mutation/backfill operation but never states required authorization (the controller_actor_id/controller_token suggest a control plane), idempotency, conflict behavior on existing bindings, or reversibility.

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 tight sentence with no filler, and the action leads the clause. Its brevity is not the problem — the abstraction is — so it earns credit for structure without reaching a 5.

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

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

An output schema exists so return values need not be explained, but for a six-parameter mutation with zero annotation and zero schema coverage, the description omits who may invoke it, what state is mutated, and how it relates to the many adjacent binding/family tools.

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 six parameters, and the description only loosely gestures at 'family state'. It adds no meaning for family_id, project_id, controller_actor_id, controller_token, source_ref, or title, leaving the agent to guess at the required control-plane actors.

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 recognizable action (binding state to a WorkIdentity) via a backfill, which is more than a tautology. However, 'historical canonical family state' is domain jargon that does not clearly distinguish it from siblings such as bind_work_turn, effective_family_view, or bind_contract_turn.

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 this tool should be used versus alternatives, no preconditions, and no note on when not to use it. The clause 'without inventing user intent' gestures at a constraint but does not give an agent any actionable routing guidance relative to the many bind_* and family_* 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?

With no annotations, the description carries the full behavioral burden. It discloses only that 'Domain failures are returned as structured error data' and that a stable AUTO-* id is generated when slice_declared_id is omitted. It does not state whether the tool performs writes, what state it creates, permissions required, idempotency, or other mutation-side effects, leaving major behavioral traits undocumented.

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 reasonably concise at four sentences and front-loads the composite purpose before moving to parameter variants and failure behavior. Most sentences earn their place, though the phrase 'without MangoMe jargon' is vague and adds little operational value.

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

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

For a complex 18-parameter composite mutation with no annotations, the description is incomplete. Output schema exists, so return values need not be detailed, but the description leaves most parameter semantics, usage versus siblings, and behavioral side effects unexplained, so an agent would struggle to invoke the tool correctly without additional inference.

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 18 parameters, so the description must compensate. It adds meaning for a few optional parameters — proposed_slice, slice_title, slice_objective, and slice_declared_id — but leaves required parameters (family_id, actor_id, request_text, intent) and many optionals (classification, expected_scope, expected_artifacts, acceptance_expectations, estimate, etc.) completely unexplained.

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

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

The description states a composite sequence — 'Compose intake -> plan -> start' — which gives a rough purpose, but the verb 'Compose' is vague and the phrase 'ordinary work without MangoMe jargon' does not clarify scope. It does not distinguish this wrapper from siblings like intake_request, submit_plan, or start_slice, so an agent cannot tell when this tool is preferable to calling those separately.

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

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

The description gives caller-specific parameter guidance — 'Existing callers may pass proposed_slice' versus 'Zero-touch callers can instead pass slice_title' — which is useful. However, it never says when to use this tool versus the many sibling tools such as intake_request, enter_work, or start_slice, nor does it provide any exclusions 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?

With no annotations, the description bears the full burden of disclosing behavior. It only states the purpose and a usage restriction; it says nothing about side effects, required permissions, rate limits, or what the tool actually does beyond 'discovery.' It doesn't even indicate whether it is read-only or mutating. This is a significant transparency gap for a tool with zero annotation 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 description is exceptionally brief – one sentence with two clauses. It is concise and front-loads the core purpose, but it sacrifices necessary detail. It doesn't waste words, but it under-delivers on content. As a result, it is appropriately sized for what it says, but that size is too small for the tool's complexity.

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 three parameters, zero schema descriptions, and no annotations, the description is far from complete. It does not explain how to use the tool, what inputs are required, or what the output represents (though an output schema exists, the description adds no context). The tool is sufficiently complex that the description should provide at least a minimal example or note about the 'roots' parameter, but it does not. The description leaves an agent with insufficient information 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%, meaning the description must compensate for the lack of parameter documentation. However, the description does not mention any of the three parameters (roots, id_patterns, include_git) or their semantics. The agent must rely solely on the bare schema property names, which are insufficient. This is a critical failure to aid parameter understanding.

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: 'Candidate-only onboarding discovery' – a clear verb+resource with a defined scope (candidate onboarding). It also draws a boundary against recovery/state reconstruction, which distinguishes it from recovery-related siblings like session_restore and recovery_context. However, the phrasing is terse and doesn't elaborate on what 'discovery' entails, so it stops short of being fully self-explanatory.

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

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

The description gives a clear when-not-to-use: 'Forbidden as a recovery/state reconstruction path for admitted work.' It implies when to use (for candidate onboarding) but does not name alternative tools or explain what to use for recovery instead. The exclusion is useful but the guidance on alternatives is implicit rather than explicit, so a 3 is appropriate.

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

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

No annotations are provided, so the description carries the full behavioral burden. It communicates the core binding action and the important rule that restore alone is insufficient, but it omits mutation effects, permission requirements, idempotency, and reversibility.

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

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

The description is two short sentences and front-loads the core action before the critical constraint. Every sentence adds some signal, and there is no wasted wording.

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 contract-binding tool with 5 undocumented parameters and no annotations, the description is too sparse. It gives the central purpose and one important rule, but lacks parameter semantics, operational context, and usage alternatives.

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

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

There are 5 parameters with 0% schema description coverage, and the description does not mention or explain any of them. In particular, request_text, mode, actor_id, contract_ref, and ttl_minutes remain fully 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 states a specific verb and resource pairing: binding the CURRENT user turn to one canonical Contract. It is clear enough to distinguish from generic state tools, but it does not explicitly differentiate itself from the sibling bind_work_turn or contract_state tools.

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

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

The sentence 'Restore state alone never authorizes this turn' implies that this tool is required after restoring state to authorize the current turn. However, it does not explicitly state when to use this tool versus alternatives, nor does it name sibling tools 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?

With no annotations, the description carries the full burden, and it discloses one meaningful behavioral fact: this is the control-plane authority-granting path and workers cannot self-mint authority. However, it says nothing about side effects, idempotency, required privileges for the controller fields, failure modes, or what happens to prior bindings.

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

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

Two tight sentences with the primary action front-loaded and no filler. The second sentence earns its place as scoping context rather than repeating the name.

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

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

Despite having an output schema, this is a complex authority-binding operation with 6 params, 5 required, no annotations, and 0% param coverage. The description omits prerequisites, mode values, token semantics, and error behavior, leaving it far too thin 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 0% across 6 parameters, and the description explains none of them. work_ref, mode, actor_id, controller_actor_id, and controller_token all go undocumented in both schema and prose, so an agent has no semantic guidance for any argument.

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: 'bind the current user turn to durable WorkIdentity.' The action is identifiable, but the jargon ('Control-plane', 'WorkIdentity') and the absence of any reference to the near-identical sibling bind_contract_turn leave the agent without sibling differentiation.

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

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

The second sentence ('Workers cannot self-mint authority') is a rationale/constraint, not when-to-use guidance. There is no statement of preconditions, no when-not-to-use, and no routing toward or away from bind_contract_turn or enter_work/begin_work.

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 says almost nothing. 'Summarize' weakly implies a read, but there is no disclosure of permissions, side effects, mutation risk, caching/freshness semantics, or what a 'support state' means. For a bitemporal status tool with zero annotation coverage, 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?

A single front-loaded sentence with no filler; the issue is under-specification rather than verbosity. It is as short as it can be while still naming an 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?

An output schema exists, so return values need not be explained, but that is the only structural aid. With no annotations, no parameter documentation, and undefined terminology, an agent lacks enough context to call this confidently or to prefer it over the sibling truth tools.

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 work_ref has no description in the schema. The description's 'one WorkIdentity' hints that the parameter is a scoping identifier, but it never states what form work_ref takes or how it relates to a WorkIdentity, so it only partially compensates 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?

It names a verb ('Summarize') and a scope ('one WorkIdentity'), so the operation is identifiable, but the core resource phrase 'current BTTM/1 support states' is opaque jargon that an agent cannot decode without domain knowledge. It also offers nothing to distinguish it from the many truth-related siblings like truth_at, truth_assertion_status, or record_truth_assertion.

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 truth_at or truth_assertion_status, which sit in the same truth-assertion family. The agent is left to infer the selection criterion 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?

With no annotations provided, the description carries the full burden. It does disclose two important behavioral traits: the tool does not execute the command and does not read environment values. However, it does not disclose side effects, whether state is mutated, or what a 'binding' actually produces beyond the output schema.

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

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

A single front-loaded sentence that states the purpose first and appends the constraints. Every word earns its place with no filler.

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

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

For a 10-parameter tool with zero schema coverage and no annotations, the description is incomplete. It never explains what an 'RB/1 reproduction binding' is for, what output the agent should expect (despite an output schema), or what distinguishes this build step from related reproduction/execution tools among the many 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?

Schema description coverage is 0% across 10 parameters, so the description must compensate. It loosely maps 'files' to input_paths and 'Git metadata' to git_commit, and 'environment values' to environment_names, but leaves command, cwd, exit_code, stdout_sha256, stderr_sha256, max_hash_bytes, and output_artifact_id entirely unexplained. This is insufficient compensation 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 names a specific verb ('Build') and a specific resource ('RB/1 reproduction binding'), and states the data sources (current files/Git metadata). It also conveys key constraints (no command execution, no environment reads). It doesn't explicitly differentiate from siblings, but the 'RB/1' qualifier plus the non-execution constraint make it reasonably distinguishable.

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

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

The phrase 'without executing the command or reading environment values' implies an offline/metadata-only mode, which is a soft usage hint. However, there is no explicit guidance on when to choose this over alternative tools or when not to use it — no named siblings or conditions are given.

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 only establishes that this is a write ("Persist"). It says nothing about idempotency, whether a new checkpoint supersedes prior ones, retention or overwrite behavior, required permissions, or any rate/ordering constraints — all material for a crash-recovery write.

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

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

Two sentences, no filler, and the primary purpose statement is front-loaded ahead of the constraint. It is efficient, though the brevity shades into under-specification rather than disciplined editing.

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 six-parameter, nested-object mutation with zero annotation coverage and zero schema descriptions, the description is far too thin. It covers the work_ref prerequisite but leaves the agent without enough context to construct payload, kind, or the plan/turn linkage 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% across six parameters, so the description must compensate and largely does not. The single constraint it adds (the reference must map to an existing canonical WorkIdentity) clarifies work_ref, but kind, payload, plan_id, turn_id, and actor_id remain entirely unexplained.

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

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

The description gives a verb ("Persist") and a resource ("crash-recovery state"), so the general intent is inferable, but "PROGRESSIVE crash-recovery state" is jargon that never says concretely what is being written (a snapshot? a delta? a pointer?). It also does nothing to separate this from siblings such as begin_work, bind_work_turn, or backfill_work_identity.

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 second sentence supplies a real precondition — the work reference must already exist as a canonical WorkIdentity — which implies when this tool is valid versus when it is not. However, no alternative tool is named for the otherwise-implied case, and there is no guidance on when a checkpoint should be taken relative to begin_work or bind_work_turn.

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?

There are no annotations, so the description must carry the full behavioral burden. It does contribute a meaningful behavioral guarantee: recording DONE_CLAIMED 'never implies verification.' It also scopes the action to the 'active plan.' Still, it does not disclose side effects, failure conditions, idempotency, or what happens if no active plan exists, leaving notable transparency gaps.

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 semicolon-joined sentence that is front-loaded with the core action and carries an important caveat, with zero filler. It is concise in form, though the brevity contributes to missing behavioral and parameter detail. Still, as a structure it 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 4-parameter mutation-style tool with no annotations and zero schema description coverage, the description is not complete enough. It gives the core semantic intent and one critical exclusion, but an agent would still be left guessing about required actor context, optional summary usage, and relationship to other status-changing siblings like completion_review or submit_evidence.

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 should compensate for all four parameters. It only implicitly references slice_id and plan_id via 'slice's active plan'; actor_id and summary are entirely unexplained. This is a partial but insufficient contribution to parameter clarity.

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

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

The description uses a specific verb ('Record') and names a concrete resource/action ('DONE_CLAIMED under the slice's active plan'), which goes far beyond the tool name. The explicit caveat 'never implies verification' immediately separates it from sibling tools like verify_slice, giving an agent a clear sense of what this tool is and is not.

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

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

The description implies when to use it: when you want to record a done claim rather than perform verification. However, it never names an alternative tool or states a concrete condition such as 'use verify_slice when actual verification is needed.' The guidance is contextually suggestive but not explicit enough to earn a 4.

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 burden of behavioral disclosure. It does reveal a key effect ('stops generating collision traffic'), but it does not disclose side effects, reversibility, permissions, or what 'close' actually does to the plan beyond stopping traffic.

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

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

The description is a single sentence with no wasted words. It front-loads the action and object, then gives the purpose. Every part 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?

The tool has two required parameters, no annotations, and no parameter documentation, yet the description does not explain actor_id or the meaning of 'unbound plan' and 'collision traffic'. While an output schema exists and return values need not be described, the missing parameter semantics and side-effect context make this incomplete for safe 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%, and the description does not mention plan_id or actor_id at all. The schema only provides field names and types, so the agent cannot infer what values are expected, why actor_id is required, or how the parameters relate to closing a plan.

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

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

The description uses a specific verb ('Close'), a specific resource ('an unbound plan'), and a concrete outcome ('stops generating collision traffic'). It is clearly distinguishable from sibling tools like submit_plan and start_slice, even without explicit sibling comparison.

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

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

The description implies when to use the tool: when an unbound plan is generating collision traffic and should be stopped. However, it does not explicitly state when not to use it or mention any alternative tools, leaving some inference to 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, and it does disclose one non-obvious trait: closure does not promote underlying work to VERIFIED. It is silent on permissions/actor requirements, reversibility or idempotency of closing, and what happens to recorded findings.

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 tight sentence with the precondition front-loaded and a second clause that adds distinct information. No filler, though the terseness borders on underspecification.

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

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

An output schema exists, so return values need not be described, but for a mutation tool with zero annotations and fully undocumented parameters the description should cover required authority and the effect on audit state. It covers the precondition and one side-effect constraint and little else.

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 none of the three parameters (audit_id, actor_id, optional summary) are explained in the description. The description does not compensate at all for the schema gap, leaving actor attribution and summary semantics 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 verb 'close' plus the tool name identifies the resource (a scoped audit), and the clause 'closure never promotes underlying work to VERIFIED' actively separates it from verification-oriented siblings like verify_slice and accept_slice. It stops short of a full plain-language statement of what closure does to the audit record 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?

'Close only after no pending frontier remains' states an explicit gating precondition for invocation, which is real when-to-use guidance rather than vague implication. It does not, however, point at siblings such as audit_status or audit_mutation_allowed for checking the frontier before calling.

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 exist, so the description bears the full burden. The clause 'without mutating canonical truth' is a real behavioral disclosure (implies a read-only/non-mutating computation), which merits more than a 1, but permissions, cost, failure modes, and side effects are entirely 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?

A single front-loaded sentence with no padding or redundancy. The problem is under-specification rather than verbosity, and the sentence itself is efficiently constructed.

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 tool with no annotations and zero schema description coverage, the description is far too thin. An output schema exists so return format is partly covered, but the inputs and invocation context remain completely unexplained.

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

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

Four parameters at 0% schema description coverage, and the description adds no meaning for any of them (slice_id, family_id, query_text, max_active_objects). It neither explains what family_id identifies nor what 'max_active_objects' bounds.

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

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

The verb 'Compute' is generic and the resources ('PCH/1 thermal map', 'bounded active working set') are undefined internal jargon, so an agent cannot infer what the tool actually produces or how it differs from any sibling. It is more than a bare tautology because a subject is named, but the naming conveys no actionable 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, when not to, or which sibling to prefer. The sibling list contains dozens of lifecycle/context tools, and nothing here 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, the description bears full behavioral disclosure. It mentions 'deterministic' but does not state side effects, permissions, idempotency, or whether the tool mutates state. 'Produce' is ambiguous about read vs write 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?

A single sentence with no wasted words, but it is under-specified rather than concise. The front-loaded verb is fine, yet the rest is too terse to be useful.

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

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

The tool has an output schema and no annotations, but the description omits parameter meanings, behavioral traits, and any differentiation from the many siblings. It is not complete enough for an agent to confidently invoke it.

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

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

Schema description coverage is 0%, and the description does not mention either parameter. Required family_id and optional slice_id are left completely unexplained, so the description 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 a verb 'Produce' and a resource 'execution package' but 'PCH/1 working-set selection' and 'compact deterministic execution package' are undefined domain jargon. It does not clearly distinguish this tool from siblings like compile_uai_context or prepare_assignment.

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?

Only implies a prerequisite ('after PCH/1 working-set selection') but gives no explicit when-to-use guidance, no alternatives, and no conditions for choosing this tool over related ones. 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?

There are no annotations, so the description carries the full burden. It does disclose meaningful behavior: it produces a versioned, compact packet, includes a semantic hash, and reports savings metrics. However, it does not state whether compilation has side effects, whether it is idempotent, whether it requires existing state, or what canonical truth depends on.

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 dense sentence that packs the purpose, input source, output format, versioning behavior, and computed metrics. There is no filler, and the core action is front-loaded.

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

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

The output schema helps with return values, but the tool still lacks usage guidance and completely omits parameter semantics. For a compile operation with 2 parameters and no annotations, an agent cannot confidently invoke it correctly from this description alone.

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

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

Schema description coverage is 0% and the description does not mention family_id or slice_id at all. The description entirely fails to explain what family_id identifies or how slice_id changes compilation, leaving an agent with two parameters and no semantic guidance.

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

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

The description states a specific action (compile), a clear source resource (canonical MangoMe truth), and a concrete output (versioned compact UAI/1 execution packet with semantic hash and savings metrics). It is distinct enough from sibling tools like expand_uai_context, decode_uai_result, and compile_execution_context, though it never names them directly.

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

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

The description gives no guidance on when to use this tool versus alternatives such as compile_execution_context, expand_uai_context, or read_context. There are no prerequisites, exclusions, or context cues that would help an agent decide this is the right compilation step.

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 is the only behavioral disclosure. It indicates a state-changing action and one consequence (recovery can continue), but does not say whether closing is reversible, what side effects occur, what happens if the delegation is already closed, or any authorization requirements.

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

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

The description is a single, front-loaded sentence with no filler; it communicates the action and purpose efficiently. It loses a point only because 'Checkpoint/close' is compact to the point of being ambiguous.

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

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

Despite the presence of an output schema, the description is too thin for a 6-parameter tool with no annotations. It fails to explain required parameters, optional outcome fields, or the lifecycle context needed to invoke the tool correctly.

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

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

Schema description coverage is 0%, and the description provides no meaning for any of the 6 parameters. Terms like status, artifact, missing_delta, and next_dependency are left entirely unexplained, so an agent cannot correctly populate them from this 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 states a specific action ('Checkpoint/close') applied to a specific resource ('a bounded delegation') and gives a clear rationale ('so recovery can continue without rediscovery'). It distinguishes the tool's role from siblings like delegation_status or authorize_delegation, though it does not name them.

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

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

The rationale implies the tool is used at a delegation checkpoint during recovery, which is useful contextual guidance. However, it gives no explicit when-to-use versus alternatives, no exclusions, and no conditions under which a delegation should not be completed.

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 burden of behavioral disclosure. It says the tool 'builds' a brief, but does not state whether this is a read-only operation, whether it persists anything, requires special permissions, or has side effects.

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

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

The description is a single, front-loaded sentence with no filler. It conveys the core purpose efficiently, though the unexplained 'AV/1' jargon slightly reduces clarity.

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

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

The presence of an output schema reduces the need to describe return values, but the description still lacks usage context, parameter semantics, and behavioral transparency. For a 2-parameter tool with no annotations, this is incomplete.

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

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

Schema description coverage is 0%, so the description must compensate. It vaguely maps 'optional observed change set' to changed_paths, but slice_id is not explained at all, and the relationship between the described inputs and the parameters is left implicit.

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 ('Build') and resource ('AV/1 adversarial verification brief') and names the input sources. It is clear about what the tool produces, though it does not explicitly differentiate it from sibling tools like verify_slice.

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

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

The description implies the tool is used after DONE claims and evidence have been persisted, and optionally with a changed set. However, it gives no explicit guidance about when to choose this tool over alternatives such as verify_slice or claim_done.

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 provided, so the description carries the full behavioral burden. It discloses that generations are immutable canonical and that physical paths are bindings not identity, but omits read-only confirmation, permission requirements, and error 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?

Two sentences, front-loaded purpose, no redundant text. The second sentence adds domain context and is not padding, though it is somewhat abstract.

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?

Output schema exists, so return values need not be explained. However, with no annotations and 0% parameter description coverage, the description leaves include_content behavior and contract_ref format unaddressed, making it incomplete 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 coverage is 0% and the description adds no meaning for contract_ref or include_content. Parameter names alone must carry all 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?

States a specific verb 'Read' and resource 'logical Contract' plus scope 'immutable canonical generations.' Distinguishes read from write siblings like register_contract, but does not name alternatives such as resolve or truth_at.

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 explicit when-to-use or when-not-to-use guidance; no alternative tools named. Usage is only implied by the verb 'Read.'

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 does disclose one meaningful behavioral trait — that this is an administrative operation requiring control-plane authority — which is genuine added context beyond the schema. However, it says nothing about mutation effects, idempotency, or what the controller_token/controller_actor_id parameters imply behaviorally.

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 clause with no waste, but it is under-specified for a six-parameter mutation tool rather than truly concise. Brevity here comes at the cost of completeness.

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

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

An output schema exists so return values need not be explained, but for a creation/mutation tool with no annotations, six undocumented parameters, and only an authority note, the description leaves too much unspecified for an agent to invoke it confidently.

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?

Six parameters with 0% schema description coverage, and the description adds nothing about any of them. The required family_key/title and the optional scope_ids, project_ids, controller_token, and controller_actor_id are undocumented in both the schema and the description, 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?

States a specific verb and resource ('creation' of a 'durable-family'), which is distinguishable from siblings like create_project and create_spec. It lacks explicit differentiation language, but the resource noun is unique enough for an agent to identify 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?

The phrase 'requires control-plane authority' gives a prerequisite/context cue for when this tool is available, but no alternatives are named and no when-not-to-use guidance is given. Usage 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?

No annotations are provided, so the description carries the full burden, and it does disclose one genuinely useful behavioral trait: the control-plane authority requirement. However it says nothing about side effects, uniqueness/conflict behavior on project_key, or reversibility, which matters for a creation tool with zero annotation coverage.

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 clause, so there is no wasted padding and the key constraint is front-loaded. Brevity here reflects under-specification rather than disciplined conciseness, but structurally it is 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?

An output schema exists so return values need no explanation, but the description remains thin for a 5-parameter mutation with no annotations and no parameter documentation. The authority note is the one substantive point; the rest of what an agent needs to call this correctly is absent.

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, and the description adds no parameter-level meaning whatsoever. Nothing explains project_key, controller_token, or controller_actor_id, so the description fails to compensate for the total 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 phrase 'Administrative identity creation' gestures at creation but names the resource as 'identity' rather than 'project', and never states plainly what the tool produces. It is more label than description, leaving the agent to infer the resource from the tool name. Sibling tools like create_family and create_spec show a naming convention that this description does not reinforce.

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

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

The description states a prerequisite ('requires control-plane authority') but gives no when-to-use, when-not-to-use, or alternative-tool guidance. With many creation-flavored siblings (create_spec, create_family, register_contract), the agent gets no help distinguishing this from 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?

No annotations are provided, so the description carries the full behavioral burden. 'Append' implies mutation and 'normative' implies authority, but the description does not disclose permissions, side effects, reversibility, conflict handling with supersedes_spec_id, or authentication needs for a 14-parameter write operation.

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

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

The description is very short and front-loads the core purpose, with no wasted words. However, for a 14-parameter tool, two terse sentences are underspecified rather than appropriately sized, so it is only minimally 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?

Output schema exists, so return values need not be explained. But with no annotations, 0% schema description coverage, and 14 parameters, the description is missing almost all operational context: required permissions, parameter meanings, when to use it, and how work-bound families must supply a MODIFY WorkTurn.

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 14 parameters, and the description does not explain any parameter. The phrase about 'MODIFY WorkTurn' loosely hints at turn/work binding but does not name or clarify turn_id, work_id, family_id, objective, constraints, or any other field.

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 ('Append') and resource ('normative Specification truth'), giving a clear high-level purpose. It does not differentiate this tool from siblings such as record_truth_assertion or create_family, but the core action is identifiable.

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

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

It provides one conditional prerequisite: 'Work-bound families require a MODIFY WorkTurn.' However, it gives no guidance on when to use create_spec versus alternatives, no exclusions, and no workflow ordering beyond that single condition.

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 burden of behavioral disclosure. It states the key trait that it never mutates canonical state, which is important. However, it does not describe error handling, what happens on validation failure, or any other side effects. The disclosure is moderate, not exhaustive.

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

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

The description is two concise sentences: 'Validate and expand a compact UAI/1R worker result. This never mutates canonical state.' It front-loads the core purpose and adds a critical behavioral guarantee with zero filler. Perfectly structured for quick parsing.

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

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

The description covers the main purpose and non-mutation, and an output schema exists to handle return values. However, it omits details about validation semantics and the specific role of expected_context_hash, leaving some gaps in completeness for a 2-parameter tool. It is adequate but not exhaustive.

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

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

Schema description coverage is 0%, so the description must compensate. It implies that result_json is the compact worker result and mentions validation, which likely involves expected_context_hash. However, it does not explicitly define either parameter, leaving some ambiguity. It adds partial meaning but not enough to fully offset the 0% coverage.

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

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

The description states a specific verb ('validate and expand') and resource ('compact UAI/1R worker result'), and clarifies it never mutates canonical state. This clearly distinguishes it from mutation-heavy siblings like compile_uai_context or render_uai_result, making the tool's purpose unambiguous.

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

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

The description gives a clear context: it is used for validating and expanding a compact UAI/1R worker result. It does not explicitly mention alternatives or exclusions, but the context is specific enough that an agent can infer when to use this tool. It lacks explicit 'when-not-to-use' guidance, so it stops short of a 5.

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

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

No annotations are provided, so the description carries the full burden. It adds useful context by calling the state 'persisted' and 'checkpoint', implying a durable read-only query. However, it does not disclose auth requirements, error behavior, freshness, or whether the state reflects in-flight delegation.

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

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

A single, front-loaded sentence with no filler. Every word adds meaning: action, resource, persistence qualifier, and 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?

The tool is simple (one required parameter) and has an output schema, so not describing return values is acceptable. However, the missing parameter semantics and absence of any usage guidance leave a meaningful gap 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% and family_id is only shown with its title. The description mentions 'one family' but does not explain what family_id is, how to obtain it, or what format/value constraints apply.

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

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

The description names a specific verb ('Return'), a specific resource ('persisted delegation/checkpoint state'), and a clear scope ('for one family'). This distinguishes it from mutation siblings like authorize_delegation and complete_delegation.

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

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

The description gives no guidance about when to use this tool versus alternatives. With many sibling status/state retrieval tools (status, workspace_status, effective_family_view), the agent is left to guess which one fits its situation.

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 transparency burden. It usefully discloses a key negative behavior (no scanning or content admission) and 'Return' implies read-only retrieval, but it does not address side effects, permissions, or error behavior.

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

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

The description is compact and front-loaded: the verb and resource appear first, and the negative scope statement earns its place. There is no filler or redundant restating of the tool name.

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

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

Even with an output schema present, the description leaves key gaps: what 'discovery scopes' are, how workspace_root affects results, and when to choose this over the many sibling tools. It is too terse for a fully informed agent 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%, and the description never mentions workspace_root, its meaning, format, or effect on the returned scopes. The description adds no parameter-level value beyond the schema's name and default.

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

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

The description uses a specific verb ('Return') and resource ('portable typed discovery scopes'), and explicitly contrasts with content scanning/admission. This distinguishes it from sibling tools like filesystem_scan and intake_request, though the term 'discovery scopes' remains domain-specific.

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 clause 'this does not scan or admit content' implies exclusions and indirectly points toward alternatives like filesystem_scan or intake_request. However, it never states a positive use case, prerequisites, or explicit routing conditions.

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

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

With no annotations, the description must carry the behavioral disclosure burden. 'Return' weakly implies a read operation, and 'append-only' describes the view's nature rather than the operation's behavior. There is no explicit statement that the call is side-effect-free, no failure/side-effect context, and no explanation of how conflicts are resolved.

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

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

A single sentence that leads with the verb and object, then lists the key output categories. Every word earns its place; there is no filler or redundant restatement of the tool name.

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

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

The output schema covers return structure and the description names the major result categories, so the return side is adequately addressed. However, with no annotations and no usage or parameter guidance, the description is only minimally complete for an agent deciding when and how to invoke this tool among many sibling view/query tools.

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 description coverage for the single parameter, and the description never directly explains family_id. The phrase 'contract-family view' is a weak clue connecting family_id to the family domain, but the description does not compensate for the missing schema coverage with format, provenance, or constraint details.

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

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

The description uses a specific verb ('Return') and names a precise resource ('effective append-only contract-family view'), then enumerates the main output categories: supersession, relations, and conflicts. It is clear, but it does not explicitly differentiate this from sibling read/view tools such as graph, resolve, or project_overview.

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. The agent is not told how this view differs from sibling tools like graph, resolve, or project_overview, so usage must be inferred 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 does disclose real behavioral traits – the workspace becomes a deterministic Project/Family + WorkIdentity, the request is admitted as an operational-intent baseline only, and discovery candidates are never auto-promoted. However, it omits idempotency, permissions, reversibility, and escalation semantics for a mutation-style 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 three short paragraphs are reasonably front-loaded, but the middle and final sentences are dense internal jargon that restates governance philosophy rather than adding callable information. Size is acceptable; the wording is opaque rather than wasteful.

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 12-parameter governance tool with no annotations, the description is far too abstract to guide correct invocation. The presence of an output schema relieves it of explaining return values, but it still fails to cover parameter intent, prerequisites, or how to choose it over near-identical 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?

There are 12 parameters with 0% schema description coverage, and the description addresses none of them. Terms like 'actor_id', 'controller_token', 'required_evidence', 'expected_scope', and 'slice_objective' are entirely undocumented, so the agent has no basis for supplying anything beyond the two required fields.

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

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

The description uses an abstract verb+resource ('Enter governed work') but never states concretely what the tool creates or returns. It is heavily laden with internal jargon (MangoMe identifiers, WorkIdentity, operational-intent baseline) and gives no way to tell it apart from close siblings like begin_work, start_slice, or intake_request.

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 a faint usage hint ('from ordinary user intent with no MangoMe identifiers required') implying use when IDs are absent, but no explicit when/when-not and no alternatives are named. With dozens of similarly named sibling tools, this leaves the agent guessing.

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, and it does so well by explicitly stating the tool never reruns commands and never changes assurance state. This effectively communicates a read-only, non-mutating safety profile, though it does not address auth requirements or failure 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?

Two tight sentences deliver the core purpose and the critical negative behavior with no filler. The information is front-loaded and every clause 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?

The description gives a clear purpose and safety profile, and the output schema presumably covers return values. However, with no annotations and zero parameter documentation, the agent is left guessing about what evidence_id should contain and what live_check controls, which is a meaningful gap 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%, so the description must compensate by explaining the parameters. It does not mention evidence_id or live_check at all, leaving their semantics completely undefined beyond the raw schema field names.

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

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

The description names a specific verb ('Check') and resource ('attested PASS evidence') and adds the precise scoping condition ('under legacy hash bindings or RB/1 reproduction bindings'). It also clarifies what the tool does not do, which helps distinguish it from verification and attestation 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?

The description implies the tool is for checking freshness without side effects ('Never reruns commands or changes assurance state'), giving clear context for when to use it. It does not explicitly name alternatives or exclusion conditions, so it stops short of a full 5.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns an authorization decision but does not dispatch the model, which is critical behavioral information. However, it doesn't disclose details about authorization decision types, potential side effects (read-only vs mutation), or what happens on failure, which are gaps given the lack of annotations.

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

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

The description is concise and front-loaded with the core purpose, followed by necessary clarifications about dispatch enforcement. The second paragraph is slightly verbose but adds critical context. Overall, it is structured well with minimal waste.

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

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

The tool has 6 parameters and an output schema, but no parameter descriptions in the schema. The description provides high-level context (authorization decision, enforcement boundary) but lacks detailed parameter semantics and behavioral specifics like return value structure, error handling, or side effects. Given the complexity and missing schema descriptions, the description is incomplete.

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

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

Schema coverage is 0%, so the description must compensate, but it does not explain any of the six parameters (worker_key, cost_ceiling, required_capabilities, etc.). The description only mentions 'runtime capabilities/cost' at a high level. With zero schema descriptions, this is a significant gap; the description could have outlined the meaning of cost_ceiling or required_capabilities.

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

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

The description clearly states the tool evaluates the worker's current runtime capabilities/cost before dispatch or a protected action, distinguishing it as an authorization check rather than a dispatch mechanism. It mentions 'MangoMe' and 'orchestrator' which could be more explicit but overall the purpose is clear and specific.

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

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

The description provides clear guidance on when to use the tool (before dispatch or protected actions like DEPLOY) and explicitly states that the external orchestrator must enforce negative decisions, implying when not to rely on this tool for enforcement. It doesn't name specific sibling alternatives but the context is sufficient.

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 entire burden. It discloses that the tool 'verify its hash,' which is a behavioral trait, but provides no other details—such as side effects, error behavior, or whether it is read-only. The description is too sparse to give an agent confidence about the tool's behavior beyond the stated operation.

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

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

The description is a single, concise sentence that front-loads the verb and keeps essential information. It is appropriately sized for the operation, though it is dense and uses specialized jargon that may hinder comprehension. Efficiency is good, but clarity suffers slightly from terminology.

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

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

The tool is an obscure, domain-specific operation with no usage context or differentiation from numerous siblings. The output schema exists but the description doesn't need to explain returns. However, it omits when to use this tool versus compile_uai_context or decode_uai_result, and lacks details on hash verification behavior or failure modes. An agent would struggle to decide when to invoke it.

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

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

Schema description coverage is 0%, so the description must compensate. It loosely ties the parameter `wire` to a 'UAI/1 context packet,' giving some meaning, but does not explain the format, constraints, or how the packet is structured. For a single parameter with no schema documentation, this is insufficient.

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

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

The description states a specific action: 'Round-trip a UAI/1 context packet back into its canonical semantic execution projection and verify its hash.' It identifies the resource (UAI/1 context packet) and the verb (round-trip, verify). It is clear what the tool does, though it does not explicitly differentiate from siblings like compile_uai_context or decode_uai_result, so it's not a 5.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention any conditions, prerequisites, or exclusions. The description only states what it does, leaving the agent to infer appropriate usage from the domain 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 carry the behavioral burden. "Read" establishes this is a non-mutating lookup and "persisted" hints the record must already exist, but it says nothing about authorization needs, error behavior for unknown ids, or what the fallback disposition implies operationally.

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

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

A single front-loaded sentence with no filler; the resource and its returned disposition are stated immediately. It is dense with domain jargon but not padded.

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

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

An output schema exists, so return values need not be described, and the description does say what is retrieved. However, with no annotations and no usage context, an agent still lacks the prerequisites and the distinction from the record/assess siblings to invoke this confidently.

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 gives 0% description coverage for judgment_id, so the description must compensate. It only implies the id identifies "one persisted ... judgment"; it never states the id format or where an agent obtains it, leaving the single required parameter under-specified.

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

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

States a specific verb ("Read") and resource ("one persisted FJD/1 progressive judgment") plus what it returns ("confidence/fallback disposition"). This differentiates it from siblings like assess_fast_judgment and record_fast_judgment, which write rather than read, though the "FJD/1" jargon is unexplained.

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

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

There is no when-to-use guidance, no stated prerequisites (e.g., that a judgment must first be recorded), and no named alternative among the many sibling status tools. The word "persisted" weakly implies a prior write, but nothing is explicit.

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

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

With no annotations, the description carries the full burden. It discloses a behavioral constraint (avoid inventing recovery state) but does not state whether the operation is read-only, destructive, requires auth, or what side effects occur. The cryptic warning offers minimal 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 very short and concise, but it is under-specified rather than efficiently structured. It is a single sentence with no front-loading of key information, and it omits critical details, so conciseness does not translate to clarity.

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

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

Given the tool has an output schema (which may cover returns), the description still fails to explain the tool's core purpose fully, its inputs beyond the schema, or when to invoke it. The cryptic phrasing leaves an agent with insufficient context to use it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It hints at 'declared_id' via 'declared identity' but does not explain limit or present_only. The description adds little meaning beyond the parameter names and fails to clarify their 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 ('validate') and a resource ('canonical identity'), but 'canonical identity' is ambiguous and not explicitly tied to filesystem references, despite the tool name. It is not a tautology, but it lacks the clarity needed to distinguish it from siblings like filesystem_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?

The description provides a caution ('never use lexical references to invent recovery state') but gives no explicit guidance on when to use this tool versus alternatives. It does not mention conditions or scenarios that select this tool over others.

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 bears full responsibility for disclosing safety and behavioral traits. It only says 'broad inventory', which implies a read operation but does not explicitly state read-only, performance implications, or what data is returned. Minimal disclosure, but not outright contradictory.

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 sentence, which is concise, but it is under-specified and does not front-load the core action or key constraints. The brevity comes at the cost of usefulness, so it 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?

A complex tool with 4 parameters, 0% schema coverage, and no parameter descriptions in the text is completely inadequate. The description fails to explain what the tool returns, how parameters interact, or any operational context, making it nearly impossible to use 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 description makes no mention of any of the four parameters (roots, max_depth, max_files, max_hash_bytes). Given schema description coverage is 0%, the agent has no clue what these mean or how to set them. This is a critical 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 states 'broad inventory' without a clear verb or subject, remaining vague about what is inventoried (filesystem? files? directories?). It does not distinguish from siblings like filesystem_references or bigbang_scan, and the name alone carries most of the 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?

Provides clear context: use for onboarding/maintenance, and explicitly forbidden for state reconstruction of admitted work. This gives both when and when-not, though it names no alternative tool, so it stops short of full guidance.

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

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

The description adds useful behavioral nuance—edges are 'validated,' can be 'confirmed/suggested,' and are both 'incoming and outgoing'—which goes beyond simply saying 'returns graph edges.' However, because no annotations are provided, it does not disclose error behavior, permissions, or scalability/pagination characteristics, and 'validated' is left 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?

One sentence, front-loaded with the action, and every word adds meaning ('validated,' 'confirmed/suggested,' 'incoming and outgoing'). There is no filler, repetition, or extraneous 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?

Given one required parameter, a clear return focus, and an output schema, the description covers the essentials for a simple read query. It could mention usage context or define validated/confirmed/suggested more precisely, but those gaps are minor at this complexity level.

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

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

Schema description coverage is 0%, so the description must carry the parameter semantics burden. It confirms that entity_id identifies the entity whose edges are returned, but adds no detail on ID format or accepted values. This is acceptable for a single self-descriptive parameter, though the description barely adds meaning beyond the schema title.

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 ('Return') and resource ('graph edges') with differentiating details: 'validated confirmed/suggested' and both 'incoming and outgoing.' This clearly distinguishes it from generic sibling tools like status, link_entities, or resolve, so an agent can identify the tool's purpose from the description alone.

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 graph versus alternatives, when not to use it, or what conditions make it the appropriate choice. The description only states what the tool does, leaving applicability 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 provided, the description carries the full burden. It discloses a notable behavioral trait (returns readiness even if backing-store init fails), which is valuable. However, it doesn't mention side effects, whether it's read-only, or what happens under normal conditions, leaving some uncertainty.

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

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

The description is a single, front-loaded sentence that conveys the core purpose and a critical edge case without any wasted words. It is optimally concise for a zero-parameter 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 parameters and an existing output schema, the description covers the essential behavior (readiness even on failure). It doesn't elaborate on what 'readiness' means or typical usage context, but that is largely implied and the output schema fills in return details. Minor gap: no explicit statement that this is a health check for system liveness, though the name and content suggest 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 tool has zero parameters, so per the baseline rule it scores 4. The description adds nothing about parameters (correctly, as there are none), and the schema is trivial (empty object).

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

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

The description clearly states the tool returns readiness and specifies a key condition (even when backing-store initialization fails). It is a specific verb+resource and distinct enough from siblings like 'status' or 'workspace_status', though it doesn't explicitly differentiate from them.

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

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

The description gives no guidance on when to use this tool versus alternatives. It doesn't state prerequisites, typical scenarios, or why one would call it over other status-like tools. The context is implied (health check) but not explicit.

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

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

With no annotations, the description carries the full burden and does disclose real behavior: controller authorization is required, single-project imports auto-bind to historical WorkIdentity, and productive execution needs an admitted normative target + WorkTurn. It still omits idempotency, reversibility, what existing state is overwritten, and permission specifics for a mutating import.

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-loaded and compact at three sentences with no obvious filler, but phrases like 'without inventing user intent' and 'admitted normative target' are opaque rather than informative. Density here trades clarity for brevity rather than earning every word.

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 13-parameter import with no annotations and 0% schema coverage, the description is far too thin; the output schema covers return values, but input semantics, preconditions, and side effects are largely absent. An agent could not reliably construct a correct call from this alone.

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% across 13 parameters, so the description must compensate, and it only gestures at a few concepts (project, family, controller, slices) without mapping them to any parameter. Most of the 13 fields (kind, scope_ids, storage_system, physical_location, declared_id, contract_title, etc.) receive no semantic clarification from either source.

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

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

States a specific action on a specific resource: 'onboarding of historical contract/slice state', and explicitly frames it as 'import/backfill, never restore', which separates it from siblings like session_restore and backfill_work_identity. However, 'onboarding' is dense jargon and the sentence is not immediately parseable for an agent unfamiliar with the domain.

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

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

The phrase 'This is explicit import/backfill, never restore' provides a clear when-not (not a restore operation), which is useful routing guidance. But there is no explicit statement of when to choose this over the many adjacent siblings (backfill_work_identity, register_contract, create_family), so selection guidance 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 disclosure burden. It meaningfully states that the tool persists and categorizes rather than executes, which is a useful behavioral signal. It does not mention side effects, reversibility, or whether existing state is modified, but it is not misleading.

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

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

A single sentence with the main action front-loaded and no filler, repetition of the tool name, or irrelevant detail. It is appropriately short, though brevity comes at the cost of parameter 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?

For a 5-parameter tool with no annotations and no schema descriptions, the one-line description leaves key invocation details unstated, such as what constitutes a valid request and how classification is supplied or derived. The presence of an output schema mitigates return-value ambiguity, but input semantics remain under-specified.

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 explicit meaning for request_text, family_id, source_ref, classification, or classification_source. The verbs 'persist' and 'categorize' only faintly hint at request_text and classification, so the description fails to compensate for the absent schema documentation.

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

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

The description uses a specific verb phrase ('Persist and categorize') and resource ('a new assignment') and situates the action 'before execution,' which separates it from execution-oriented siblings like begin_work and start_slice. It does not explicitly distinguish it among other creation tools such as create_project or register_contract, so differentiation is partial.

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

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

The phrase 'before execution' gives a clear temporal usage context, implying this tool belongs to the intake stage rather than execution. However, it provides no explicit when-not-to-use guidance and names no alternatives, so routing must be inferred from sibling names.

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 does so well: it discloses the side effect (propagate REVALIDATION_REQUIRED to dependents), the prerequisite (canonical MODIFY work turn), and the preservation guarantee (historical truth preserved, evidence/history never deleted). This gives an agent essential operational context for a mutation tool.

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

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

The description is two sentences, front-loaded with the core action, followed by the prerequisite and preservation guarantee. Every sentence adds distinct value with no redundancy or filler.

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

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

The tool is complex, with five parameters, no annotations, and zero schema description coverage. The description supplies important behavioral and prerequisite context, but it omits parameter semantics and usage alternatives. Given the output schema exists, return-value explanation is not required, but the definition remains incomplete for a mutation tool of this 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 0%, so the description must compensate for five parameters, four of them required. It indirectly references assertion_id and turn_id, but provides no explanation of actor_id, reason, known_at, or the expected formats. Most parameter semantics are left to the bare schema, which has no property descriptions.

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