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

No annotations are supplied, so the description carries the full behavioral burden. The phrase 'review to done' weakly implies a state transition, but the description does not disclose side effects, required permissions, idempotency, irreversibility, error behavior, or what 'independently validated' means 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?

The definition is a single sentence, but it is front-loaded with undefined jargon ('Core T4') and an ambiguous phrase ('review to done'). Brevity is not helpful here because the sentence is too opaque to orient the agent.

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

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

For a six-required-parameter approval operation with no annotations, no output schema, and zero schema descriptions, the description is drastically incomplete. It leaves the agent without the workflow, parameter meanings, or behavioral expectations needed to invoke the tool safely.

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 required parameters. The description vaguely connects to review_ref and authorization_ref via 'review and authorization evidence,' but it leaves actor, task_id, report_ref, and profile_ref completely unexplained, so it does not 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?

The description says 'Request Core T4 review to done,' which is jargon-heavy and never plainly states that this tool approves a task or transitions it to a done state. It references review and authorization evidence but does not clearly distinguish this action from siblings like reject_task, submit_task, or mark_human_approved.

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

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

There is no guidance on when to use approve_task versus reject_task, submit_task, mark_human_approved, or any other sibling. No prerequisites, exclusions, or workflow context are provided.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that Core enforces authorization and family convergence, but it does not explain what archiving actually does, whether it is reversible, what permissions are required, or what happens to related family/workflow state.

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

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

The description is a single sentence but is cryptic and under-specified rather than efficient. Crucial details are compressed into jargon like 'Core T7 done' that an agent cannot reliably interpret.

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

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

This is a complex mutation tool with 6 parameters, no annotations, and no output schema. The description does not provide enough information about purpose, preconditions, parameter meanings, or behavior for an agent to invoke it correctly.

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

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

Schema description coverage is 0% for 6 parameters, so the description must compensate heavily. It only loosely hints at authorization and family convergence, leaving task_id, actor, profile_ref, and review_ref 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 name says archive_task, but the description's phrasing 'Request Core T7 done to archive' is opaque jargon rather than a clear statement that this archives a task. It does not distinguish the operation from sibling task lifecycle tools such as approve_task, reject_task, or submit_task.

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 explicit guidance on when to use this tool, when not to, or which sibling tools are alternatives. The mention of authorization and family convergence hints at preconditions but does not tell an agent when archiving 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?

With no annotations, the description carries the full behavioral burden. It discloses that the actor records attribution and that the action 'grants no authority', which is useful, but it does not explain mutation side effects, permissions, idempotency, failure behavior, or what happens to the task state.

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

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

The definition is a single sentence and front-loads the transition phrase, so it is not bloated. However, the concise wording is cryptic and under-specifies key details rather than making every clause maximally 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?

For a two-parameter task-lifecycle tool with no annotations, no output schema, and 0% parameter description coverage, the description is too thin. It adds one safety-related behavioral note but leaves parameter roles, return behavior, and operational context largely 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?

Schema description coverage is 0%, so the description must compensate for both parameters. It gives some meaning for 'actor' by saying attribution is recorded and authority is not granted, but it says nothing about 'task_id' beyond the vague 'Core T2 inbox to active' phrase.

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 indicates a transition from 'inbox to active' for 'Core T2', which hints at claiming a task, but the phrase 'Core T2' is undefined jargon and the plain action 'claim a task' is never stated. It is specific enough to suggest a lifecycle transition but vague enough that an agent must infer the core purpose.

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

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

The description gives no explicit guidance about when to use this tool versus siblings such as submit_task, approve_task, or create_task. There are no when-to-use, when-not-to-use, or alternative-selection cues.

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 for a mutation tool, yet it discloses nothing about permissions, idempotency (despite an operation_id parameter), side effects on the root task, or whether the branch can later be merged.

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, but 'through Core T1' is unexplained jargon that consumes space without adding actionable meaning.

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

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

For a 7-required-parameter mutation with no annotations, no output schema, and zero parameter documentation, one sentence is far short of what an agent needs to invoke this 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 coverage is 0% across 8 parameters, so the description must compensate and does not: it never explains root_task_id, workspace_id, operation_id, sender/recipient/subject/body, or the P2 priority default. Worse, it references a 'branch_of relation' that has no corresponding parameter in the schema, which misleads more than it informs.

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 ('Create a branch TASK') and distinguishes itself from the plain create_task sibling by calling out the branch_of relation. The jargon 'Core T1' is undefined, but the core action is still 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?

No guidance on when to use this instead of create_task or merge_branches, and no prerequisites such as whether root_task_id must reference an existing task or what distinguishes a branch task from a root task.

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 hints at idempotency ("Repeated requests retain Core idempotency semantics") but never says what that means concretely — does the same operation_id return the same task, or error? Nothing on permissions, side effects, or whether parent/branch_of create implicit relationships.

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 padding, and the action is front-loaded. But the brevity comes at the cost of substance: both sentences are jargon-dense placeholders rather than information an agent can act on.

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

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

A 12-parameter mutation tool with no annotations, no output schema, and 0% schema description coverage needs far more than two sentences. Key gaps: relationship semantics for parent/branch_of, valid values for priority/risk_level, and what success returns.

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

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

Schema coverage is 0% across 12 parameters, so the description must compensate and largely fails. It only gestures at workspace_id scoping and operation_id idempotency, leaving parent, branch_of, thread_key, references, risk_level, and the meaning of priority "P2" 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 verb+resource ("Create a TASK") is stated, but "Core T1" and "workspace-scoped operation identity" are undefined jargon rather than a description of what a task is or how it differs from siblings like write_issue or write_report, which also appear to create work items.

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

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

No indication of when to use create_task versus write_issue, write_report, write_review, or create_branch, all of which sit in the same family of creation tools. No prerequisites, no preconditions (e.g., does the workspace need to be initialized/validated first?).

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

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

With no annotations, the description carries the full burden. It does disclose two non-obvious behaviors: the workspace is always created at the server-bound root (no path parameter, no user-chosen location), and the profile is a reference only and confers no executable authority — a meaningful safety note for a creation tool. It omits idempotency/conflict behavior, required permissions, and what artifacts get created.

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

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

Two sentences, front-loaded with the action and scope; the second sentence adds a distinct security-relevant caveat rather than padding. Slightly dense phrasing ('reference, never executable authority') costs a bit of immediate readability.

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 mutation tool with no annotations, no output schema, and an entirely undocumented parameter, the description should cover failure modes, idempotency, and what a successful initialization produces. It covers root binding and profile authority but leaves the agent unable to predict behavior on re-invocation or on error.

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

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

Schema description coverage is 0% for the single 'profile' parameter, so the description must compensate. It clarifies that profile is optional and is a non-authoritative reference, but says nothing about its expected form (path, name, identifier) or what happens when it is null versus supplied.

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 (create) and resource (canonical FCoP 4.0 workspace), and the word 'only' constrains scope so the agent knows this is not a general-purpose initializer. It implies a separation from inspect_workspace/validate_workspace but never names them or states the difference explicitly.

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

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

There is no guidance on when to call this versus inspect_workspace or validate_workspace, nor any prerequisite or exclusion (e.g., whether it fails if a workspace already exists, or when re-initialization is appropriate). The only implicit signal is 'only ... at the server-bound root', which constrains scope but not usage timing.

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 carries the full burden. 'Read' implies read-only, but it says nothing about permissions, whether the digest or convergence readiness is computed versus stored, how expensive the call is, or what happens when the root has no family.

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 compact sentence with the verb and the returned artifacts front-loaded; nothing is padded. It is terse to the point of under-specification, but that is a completeness problem rather than verbosity.

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

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

With no annotations, no output schema, and an undocumented required parameter, the description should explain the return shape and the meaning of root_task_id. As written it leaves an agent unable to predict either the input or the output.

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 single required parameter root_task_id is never mentioned in the description. It is unclear whether this is the root of a task tree, a family identifier, or a task whose descendants are inspected.

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 'Read' and the resource 'Core family membership' are stated, along with three further things returned (REPORT heads, digest, convergence readiness). But 'Core family', 'REPORT heads' and 'convergence readiness' are unexplained domain jargon, and nothing distinguishes this from sibling readers like inspect_task or read_report.

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 call this versus inspect_task, read_task, or inspect_workspace, and no prerequisites or exclusions. The agent must guess that this is the aggregate/family-level view rather than a single-task view.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only operation and hints at the data returned, but says nothing about permissions, whether the attempt/transition data can be absent or empty, cost, or any failure mode for a lifecycle-inspection tool.

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

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

A single front-loaded sentence with no filler. It is efficiently sized, though the jargon ('Core lifecycle', 'transition evidence') slightly reduces parsing speed without adding precision.

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

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

With no annotations and no output schema, the description must explain what inspection actually returns. 'Transition evidence' and 'current attempt' are never unpacked, so an agent cannot predict the response shape or know how it differs from read_task.

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

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

Schema description coverage is 0%, but the single parameter is task_id, whose name and required status make its meaning self-evident, and 'for a TASK' loosely ties it to the parameter. The description adds no format, ID-source, or scoping detail 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?

Names a specific verb (Read) and a specific resource (Core lifecycle, current attempt and transition evidence for a TASK), so the agent knows this is a diagnostic/inspection read rather than a plain fetch. However, it never distinguishes itself from the sibling read_task, which an agent could plausibly pick instead.

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

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

There is no guidance on when to use this tool versus read_task, list_tasks, or inspect_workspace. Terms like 'Core lifecycle' and 'transition evidence' hint at a debugging use case but never state the condition that selects this tool.

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

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

With no annotations at all, the description carries the full behavioral burden. 'Without repair' is a genuine disclosure that the call is non-mutating and safe to run, but nothing is said about whether it requires an initialized workspace, how expensive it is, or whether results are cached or live.

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

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

A single front-loaded sentence with no filler, which is the right size for a no-argument tool. The only weakness is that the noun list relies on undefined domain terms, so density comes at the cost of readability.

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

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

There is no output schema and no annotations, so the description is the only source of truth about what comes back. Enumerating the inspected facets is a partial answer, but an agent still cannot tell the shape of the result (per-family? per-envelope? a single blob?) or what 'recovery facts' entails.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description correctly implies no inputs are needed.

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

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

Specific verb ('inspect') with an enumerated set of facets (protocol identity, envelopes, lifecycle, families, recovery facts) and a scope qualifier ('without repair') that separates it from repair-oriented siblings. It falls short of 5 because the facet terms are domain jargon and no sibling (e.g. validate_workspace, inspect_family) is explicitly contrasted.

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?

'Without repair' implies use this when you only want to look, not fix, which is useful implied guidance. However, it never states when to pick this over validate_workspace or inspect_family, nor any precondition for calling it.

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. 'Deterministic filtering and pagination' hints at stable ordering, but it doesn't specify default ordering, maximum limit, whether omitted filters mean 'all', or what 'validated canonical' implies about data freshness.

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 clauses. It is efficiently sized, though its brevity is partly the source of the other gaps.

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?

Five undocumented parameters, no annotations, and no output schema leave the agent with little operational detail. For a filtered list endpoint, the description should at minimum clarify filter semantics and pagination defaults.

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

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

Schema description coverage is 0% for all five parameters, so the description must compensate. It only implies that sender/severity/subject_ref are filters and limit/offset are pagination, without explaining matching semantics, accepted severity values, or default behavior when filters are null.

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 (List) and resource (ISSUE facts), which distinguishes it from the task/report/review list siblings. 'Validated canonical facts' is jargon that adds little, but the core purpose is unmistakable.

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

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

No guidance on when to use this versus list_tasks, list_reports, or list_reviews, and no prerequisites or exclusions. The agent must infer usage purely from the resource name.

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

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

No annotations are provided, so the description carries the full burden and doesn't meet it. It says nothing about pagination behavior, ordering, default filtering when sender/attempt_id/subject_ref are null, or what 'head selection' actually means 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?

It is a single front-loaded sentence, so it isn't verbose, but the phrase 'including exact attempt and head selection semantics' spends words on unhelpful jargon rather than conveying information.

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

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

With 6 mostly optional filter/pagination parameters, zero schema description coverage, no annotations, and no output schema, one sentence is insufficient to call this tool correctly. Nothing explains default result sets or the meaning of the head/attempt selection modes.

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 only makes a vague gesture toward 'attempt' and 'head' semantics without explaining limit, offset, sender, attempt_id, subject_ref, or head_only. An agent still cannot tell what head_only=true does or how the filter parameters interact.

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 ('List REPORTs'), which clearly distinguishes it from read_report and write_report among the siblings. However, 'through Core' and 'exact attempt and head selection semantics' are unexplained jargon that doesn't sharpen the purpose.

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

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

No guidance on when to use this versus read_report or list_issues/list_reviews, and no prerequisites or exclusions stated. The agent must infer usage purely from the name.

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

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

With no annotations, the description carries the full burden, and it does disclose two real traits: results are limited to validated/canonical records, and the act of listing confers no authorization. It still omits whether this is strictly read-only, pagination/ordering behavior, and how multiple filters combine, leaving material gaps for an unannotated tool.

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

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

A single tightly written clause pair with the resource scope front-loaded ahead of the authorization caveat. No filler, though the compressed phrasing borders on cryptic.

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?

Six undocumented filter parameters, no annotations, and no output schema leave the agent without enough information to use filters correctly or understand what comes back. The description should at minimum explain the filter dimensions and the result shape/pagination.

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 (limit, offset, sender, decision, review_kind, subject_ref), and the description mentions none of them. An agent gets no help on what `decision` values look like, what `subject_ref` points at, or what defaults mean; only the phrase "REVIEW facts" vaguely hints at the domain.

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?

Uses a specific verb ("List") bound to a specific resource ("validated canonical REVIEW facts"), which separates it from the singular reader read_review and from list_reports/list_issues. The jargon "canonical facts" is unusual but the intent (enumerate validated review records) is inferable. It does not explicitly contrast itself with read_review.

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

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

The only guidance is the caveat "listing grants no authorization," which says what the output does NOT do but never says when to choose this tool over read_review or how to pick among filters. An agent must guess the intended use case and retrieval strategy.

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 read operation but does not disclose pagination behavior, default ordering, authentication/permission requirements, or what a 'validated canonical' fact means in practice, leaving significant behavioral 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?

The single sentence is front-loaded and free of filler, but it is under-specified rather than appropriately concise. It earns its place as a summary but omits information the agent needs.

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

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

With no annotations, no output schema, and seven parameters at 0% schema coverage, the one-sentence description is not complete enough. An agent lacks guidance on filtering semantics, pagination, ordering, and result shape.

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 all seven parameters. It mentions only 'stage' and vaguely references 'relations,' leaving limit, offset, parent, sender, branch_of, and recipient completely unexplained in both schema and description.

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

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

States a specific verb ('List') and resource ('canonical TASK facts'), so an agent knows this is a read/list operation over tasks. It does not distinguish itself from sibling list tools like list_reports or list_issues beyond the resource name, leaving some ambiguity.

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

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

Only says results can be 'optionally filtered by stage or relations,' which is a capability statement rather than guidance on when to choose this tool over list_reports/list_issues or inspect_task/read_task. No exclusions, prerequisites, or alternatives are named.

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

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

With no annotations, the description usefully discloses a security-critical behavior: caller-supplied approver text alone is never authority, and expires_at must be explicit. However, it does not describe whether this is a write operation, what permissions or issuer evidence are required, what side effects occur, or what is returned, leaving important behavioral 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?

The description is compact and front-loads the action before adding two critical constraints. Both sentences carry weight, though the second is terse and somewhat cryptic for a tool with 8 required parameters.

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, 8-required mutation-style tool with no annotations and no output schema, the description is far too incomplete. It highlights authority and expiry semantics but leaves most required parameters and the overall approval workflow 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?

Schema description coverage is 0% across 12 parameters, so the description must carry parameter semantics. It only adds meaning for two fields, approver and expires_at, and gives no explanation of required fields such as review_id, decision, profile_ref, from_stage, to_stage, or issued_at.

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 but unusually abstract action: 'Ask Core to append independent authorization evidence.' It is not a tautology, but it never plainly says this marks a human approval or explains how it differs from sibling tools like approve_task, so the agent must infer the core purpose.

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

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

There is no explicit when-to-use guidance and no mention of alternatives such as approve_task or reject_task. The description provides constraints on authority and expiry, but it does not tell the agent when this tool should be selected over its 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 must carry the full behavioral burden. It discloses atomicity and clarifies that the tool does not choose winners or archive the root, which is valuable. But for a 9-parameter mutation it omits idempotency, permission/authorization requirements, failure behavior (e.g., expected_family_digest mismatch), and what gets persisted or returned.

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

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

The description is a single front-loaded sentence with no filler: it immediately states the atomic record action and the key non-actions. It is appropriately concise, though its brevity is also a cause of missing information captured in other dimensions.

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 9 required parameters, 0% schema coverage, a nested object, no output schema, and no annotations, the description is far from complete enough for an agent to invoke this correctly. It leaves nearly every parameter and all result/error semantics undefined.

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 9 required parameters, including a nested object (branch_report_heads). The description provides no meaning for any parameter — not root_task_id, expected_family_digest, conclusion, conflict_resolution, operation_id, sender, or recipient — leaving an agent unable to fill the schema correctly.

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

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

The description states a specific action ('Record ... convergence decision atomically in Core') and adds exclusions ('never choose winners or archive the root'), which helps distinguish it from a true merge or archive operation. However, terms like 'convergence decision' and 'Core' are jargon-heavy and the purpose remains somewhat vague without schema context.

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

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

The description implies usage after a convergence decision but gives no explicit when-to-use conditions, prerequisites, or named alternatives. The exclusions ('never choose winners or archive the root') are useful but do not tell an agent which sibling tool to use instead.

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-disclosure burden. It states only 'read' and an opaque 'Core identity resolution' process, without explaining permissions, resolution behavior, error conditions, or response characteristics.

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

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

The description is a single front-loaded sentence with no wasted preamble. However, the dense jargon in 'canonical REPORT through Core identity resolution' reduces clarity rather than earning its place as useful 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?

With no annotations, no output schema, and 0% parameter description coverage, the description is too thin for an agent to know how this tool behaves beyond the bare action. It does not explain what a 'canonical' report is or how identity resolution affects the result.

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

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

The only parameter is filename_or_id, but schema description coverage is 0% and the description provides no additional explanation of accepted formats, ID resolution rules, or ambiguity handling. The parameter name itself is somewhat self-explanatory, but the description adds no semantic value.

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 a read operation on a REPORT resource, so the basic action is identifiable. However, terms like 'canonical' and 'Core identity resolution' are unexplained jargon, and the description does not differentiate read_report from siblings such as list_reports or read_task.

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 list_reports, read_task, or read_review. There are no stated prerequisites, exclusions, or alternative-selection rules.

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 partially discloses behavior: it is non-mutating ('without changing its decision') and limited to validated reviews. It does not cover permissions, failure behavior for unvalidated or missing IDs, or what the response contains.

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 phrasing 'canonical bucket' is slightly obscure, but overall it is efficient and appropriately sized.

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

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

For a simple one-parameter read tool with no output schema, the description covers the core action and read-only nature. It remains incomplete on how to obtain or format the review_id and what the read returns.

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

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

The single parameter, review_id, has 0% schema description coverage and the description says nothing about its format, source, or examples. The parameter name is self-explanatory but 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 specific verb ('Read') and resource ('REVIEW'), and adds qualifying scope ('validated', 'canonical bucket'). It is clearly distinct from write_review and list_reviews, though it does not explicitly name those 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 phrase 'without changing its decision' implies read-only usage, and 'validated' implies a constraint on which reviews can be read. However, it never states when to choose read_review versus list_reviews or inspect tools, nor any preconditions for obtaining a review_id.

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

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

No annotations are provided, so the description carries the full disclosure burden, yet it says nothing about what happens when the task_id is unknown, whether the result is a snapshot or live state, or permission requirements. "Canonical" weakly hints that the returned record is authoritative but is not elaborated.

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 the verb first and no filler sentences. It is efficient, though the brevity comes at the cost of the missing guidance 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?

With no annotations, no output schema, and an undocumented parameter, the description leaves too much unsaid for an agent to call this correctly. It omits both the identifier format and the shape of the returned task record.

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

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

There is one required parameter with 0% schema description coverage, so the description must compensate. "Typed identity" gestures at the meaning of task_id but gives no format, source, or example of what a typed task identity looks like versus other identifiers used by sibling tools.

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+resource pair ("read a canonical TASK") is clear enough, but the qualifiers "typed identity" and "through Core" are internal jargon that add no discriminating information. It also fails to distinguish itself from the sibling inspect_task, which plausibly does the same thing, so an agent cannot choose between them from the text.

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 statement of when to use this versus inspect_task or list_tasks, and no prerequisites or error conditions. The description only implies usage through the word "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 behavioral burden, but it only vaguely references a Core T5 review workflow. It does not explain what rejection does, whether it is final, what permissions or authorization are required, or what side effects occur.

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

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

The description is short but cryptic rather than concise. Jargon such as 'Core T5', 'active', and 'attempt' is not front-loaded or explained, so the single sentence 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?

For a six-parameter, fully required mutation-style tool with no annotations and no output schema, the description is completely inadequate. It does not explain the operation, the parameters, the authorization model, or the outcome.

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 six required parameters with 0% description coverage, and the description explains none of them. Terms like report_ref, review_ref, authorization_ref, and profile_ref remain completely 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?

The tool name says reject_task, but the description instead talks about requesting 'Core T5 review to active' and Core advancing the attempt. It does not clearly state that this tool rejects a task, nor does it distinguish the operation from sibling tools like approve_task or reopen_task.

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

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

There is no guidance on when to use this tool instead of approve_task, reopen_task, or other task-state tools. The description gives no conditions, prerequisites, or exclusions, so an agent cannot confidently choose it over alternatives.

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

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

No annotations are provided, so the description carries the full disclosure burden. It hints that authorization and evidence are required, but says nothing about side effects, whether the transition is reversible, what happens to prior approvals/reviews, or failure modes—significant gaps for a mutation 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 front-loaded sentence with no wasted clauses, but efficiency is undercut by opaque jargon ('Core T6', 'done to active') that consumes the sentence without adding comprehensible meaning.

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

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

For a five-parameter, all-required mutation tool with no annotations and no output schema, the description is far too thin. It neither explains the parameters nor the operational consequences of the transition, leaving the agent under-equipped to invoke it correctly.

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

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

Schema coverage is 0% across five required parameters, and the description only loosely gestures at 'evidence' and 'authorization' without mapping them to review_ref, authorization_ref, profile_ref, actor, or task_id. The agent gets no field-level meaning beyond what the bare property names suggest.

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 name and description together convey a state transition (done -> active) on a task, which distinguishes it from siblings like claim_task or submit_task. However, the phrase 'Core T6' is unexplained internal jargon that blocks a clean reading of what the tool actually does, so the purpose is only partially clear.

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 explicit guidance on when to use this tool versus alternatives (approve_task, reject_task, claim_task), nor any stated preconditions or when-not-to-use cases. 'Explicit reopen evidence and authorization' implies prerequisites exist but never spells out the conditions that should trigger a reopen.

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 fails. It does not say whether this mutates task state, what 'Core T3 active' review means, what happens if the report is stale or missing, whether the call is idempotent, or what permissions the actor needs.

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

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

One short sentence, but the brevity comes from under-specification rather than efficiency; the most important information is compressed into opaque terms like 'Core T3 active' and 'explicit current-attempt'.

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 three-required-parameter state-changing tool with no annotations and no output schema, the description supplies essentially none of the operational context an agent needs. Nothing explains the review lifecycle, preconditions, or outcome.

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

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

Schema description coverage is 0% for three required parameters, so the description must compensate and does not. 'REPORT' loosely maps to report_ref, but task_id and actor are never explained, nor is the expected format of any 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?

The phrase 'Request Core T3 active to review' gestures at submitting something for review, but 'Core T3 active' is unexplained internal jargon that an agent cannot decode. The object 'the explicit current-attempt REPORT' hints the resource is a report, yet the tool name (submit_task) and the description don't converge on a plain verb+resource statement.

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

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

There is no indication of when to use this versus write_report, approve_task, or the other task-lifecycle siblings. The word 'explicit' and 'current-attempt' imply preconditions (a report must already exist and be current) but never state them as rules.

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 does disclose two meaningful traits: the validation is deterministic and it does not touch host/runtime state or perform repairs (implying a non-mutating, sandboxed read). It omits what happens on failure, whether it raises errors or returns findings, and whether it requires a prior init.

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 the action first and the constraints second; every clause carries information. Mild jargon ('Core validators', 'canonical workspace facts') costs a little immediate comprehension but no words are wasted.

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

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

For a zero-parameter tool with no output schema and no annotations, the description covers what it validates and what it refuses to do, but leaves the agent guessing about the result shape (pass/fail? list of violations?) and about prerequisites. Adequate but with a real gap in how to interpret the outcome.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The sentence correctly implies the workspace is identified implicitly by context rather than by arguments.

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 ('validate') and resource ('canonical workspace facts') plus the mechanism ('Core validators'), which is enough to distinguish it from siblings like init_workspace or inspect_workspace. It stops short of explicitly naming the sibling it is not, so it lands at clear-but-undifferentiated.

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?

'Never repair or consult host/runtime state' provides useful exclusionary guidance about what this tool is not for, implying it should be used for static canonical-fact checking. However, it never says when to prefer it over inspect_workspace or what precondition (e.g., after init_workspace) makes it 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?

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'append' and mentions workspace/subject identity. It omits permissions, idempotency or duplicate behavior, severity semantics, and side effects for a six-required-parameter write tool.

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

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

The description is a single front-loaded sentence with no filler. Brevity is structurally appropriate, though it leaves other dimensions underdeveloped.

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, six required, no annotations, no output schema, and 0% schema descriptions, the definition is far from complete. It does not explain valid formats, required identity relationships, severity values, or expected results.

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

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

Schema description coverage is 0%, so the description should explain all seven parameters. It adds only vague meaning for workspace_id and subject_ref, leaving sender, recipient, body, severity, and references undocumented in both schema and description.

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

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

The verb 'Append' plus the resource 'Core ISSUE' makes the action identifiable and distinguishes it from list_issues and read_review siblings. 'Core ISSUE' is domain jargon that is not explained, so it is clear but not fully self-contained.

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

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

There is no guidance on when to use this tool versus list_issues or other write tools, and no prerequisites or exclusions are stated. The sentence only implies that this is a write operation.

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

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

With no annotations, the description carries the full burden; it does disclose the append-only nature and that the call does not accept or archive work, which is the key safety distinction. It says nothing about prerequisites (must the attempt exist?), permissions, idempotency of repeated appends, or failure modes for a 9-parameter mutation.

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 scope ('Append') and the key constraint (not accept/archive) come first. Its brevity is efficient, though it borders on under-specified for the parameter surface.

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?

Nine parameters, seven required, zero schema descriptions, no annotations, no output schema — this is exactly where the description needs depth, and it provides one sentence. An agent cannot tell what belongs in body versus result or what report_kind values mean.

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 9 parameters, so the description must compensate, yet it names no parameters. 'attempt' hints at attempt_id and 'TASK' hints at subject_ref, but body, result, sender, recipient, report_kind, references, and workspace_id are 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?

States a specific verb and resource ('Append a Core REPORT') scoped to a TASK attempt, and distinguishes itself from state-changing siblings by saying reporting 'does not accept or archive work'. The jargon 'Core REPORT' and 'explicit TASK attempt' keep it from being fully 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?

Provides one useful exclusion ('does not accept or archive work'), implicitly pointing at submit_task/approve_task/archive_task as the alternatives for state change. It never positively says when to choose write_report over write_issue or write_review, so guidance remains inferred.

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 carries the full burden. It notes that authority is evaluated by trusted startup Profile evaluators, which is a useful behavioral clue about authorization, but says nothing about mutation effects, required permissions, whether appends are idempotent, or what happens on failure. For a write tool with 18 parameters, this is far too thin.

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

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

Short and front-loaded with the verb+resource, so it is not padded. However, the brevity is under-specification rather than conciseness: the second sentence introduces an important authorization concept without explaining it.

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

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

No annotations, no output schema, 18 parameters with 0% schema description coverage, and a two-sentence description. The agent lacks what it needs to invoke this tool correctly: parameter meaning, review_kind/decision values, and the relationship between sender, recipient, subject_ref, and profile_ref are all 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?

Schema description coverage is 0% and the description explains no parameters at all. With 18 parameters including ambiguous fields like review_kind, decision, subject_ref, transition, family_digest, and issuer_proof, the absence of any semantic guidance is a severe 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 ("Append") and resource ("Core REVIEW"), which is better than tautology. But "typed Core REVIEW" is jargon that doesn't clarify what a review is versus a report or issue, and the description never distinguishes this tool from siblings like write_report, write_issue, or list_reviews.

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 write_review instead of write_report or write_issue, no prerequisites, no workflow context. The authority sentence hints at a gate but doesn't tell the agent when this tool is appropriate.

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