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

The description explicitly labels the tool as 'Read-only', which is helpful given no annotations. However, it lacks details on behavioral traits such as what constitutes 'specific enough', error handling, or side effects. More behavioral context would improve 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 concise at one sentence, front-loading the core purpose. While it could benefit from expansion, it avoids unnecessary verbosity. Every word earns its place.

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

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

Given the complexity (6 parameters, no output schema, 0% schema coverage), the description is incomplete. It fails to explain parameters, return values, or how 'specific enough' is determined. An agent would struggle to use this tool effectively.

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

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

Schema description coverage is 0%, meaning the schema provides no parameter descriptions. The tool description also fails to explain any of the 6 parameters (e.g., 'limit', 'format', 'chapter', 'agent_id', 'project_dir', 'required_actions'). This leaves the agent without necessary semantic information.

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's purpose: to check if desktop agent activity is specific enough for handoff. It uses a specific verb and resource. However, it does not differentiate from sibling tools like 'build_handoff_report' or 'list_agent_activity'.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, or context that would help an agent decide to invoke this tool over 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?

The description explicitly states 'read-only', which is a key behavioral trait. However, it does not disclose other behavioral aspects like permissions, side effects, or what 'copy-ready' entails. With no annotations, more detail is needed.

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

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

The description is a single clear sentence with no fluff. However, it could briefly mention key parameters like chapter or platform without becoming verbose.

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 8 parameters, no output schema, and no parameter descriptions, the description is incomplete. It tells the purpose but not how to use it effectively or what output to expect.

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 does not explain any of the 8 parameters (mode, format, chapter, platform, etc.). Schema coverage is 0%, so the description must add meaning, but it fails to do so, leaving the agent uncertain how to configure the tool.

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 verb 'Build', the resource 'copy-ready read-only startup prompt', and the context 'for a local desktop agent starting or taking over a target chapter.' This distinguishes it from sibling tools like build_agent_activity_report and build_chapter_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 context (agent startup/takeover) but does not provide explicit when-not or alternative tools. Siblings like build_chapter_context or build_desktop_next_step could be alternatives, but no guidance is 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 full burden. It states the queue is 'read-only', implying no side effects. However, it does not disclose other behavioral traits like required permissions, data sources, or what happens to the queue after building.

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 with a single sentence that front-loads the main purpose. It is reasonably efficient, though the sentence is somewhat long and could be broken into shorter statements for 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 complexity (14 parameters, no output schema, no annotations), the description is insufficient. It provides high-level purpose but lacks details on return values, parameter usage, and behavior, leaving significant gaps for the agent.

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

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

Schema description coverage is 0%, and the description does not elaborate on any of the 14 parameters. It fails to add meaning beyond the schema's structure, leaving the agent without guidance on how to use parameters like mode, limit, format, etc.

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's purpose: building a read-only queue of various items (proposals, conflicts, etc.) needed for author review before state changes. It uses a specific verb ('Build') and resource ('read-only queue'), and the mention of different item types distinguishes it from sibling tools like 'build_proposal_review' or 'build_chapter_acceptance_plan'.

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

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

The description provides no explicit guidance on when to use this tool vs. alternatives. While it implies the queue is for author review before state changes, it does not compare with siblings or specify prerequisites or when not to use 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?

With no annotations, the description carries the full burden. It states 'read-only', indicating non-destructive behavior, and outlines planned outputs (review, gates, commands). However, it does not disclose side effects, authorization requirements, or error conditions, leaving gaps in transparency for a tool with 7 parameters.

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

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

The description is a single sentence that packs significant detail (read-only, post-acceptance, components). It is efficiently structured with minimal redundancy, though slightly verbose in listing elements. Overall, concise for the information conveyed.

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

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

Given the complexity (7 parameters, no output schema, no annotations), the description is incomplete. It does not explain return format, how to use the parameters, or preconditions. For a tool generating a plan, the agent lacks understanding of what the output contains or how 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?

The description provides no explanation for any of the 7 parameters. Schema coverage is 0%, so the description adds no value. Parameters like 'handoff_chapter', 'include_context', and 'author_confirmation' remain unexplained, requiring the agent to infer from names alone.

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 builds a 'read-only post-acceptance write plan for one draft chapter' with specific components. The verb 'build' and resource are well-defined, and the listing of included elements (pre-write review, gates, etc.) distinguishes it from sibling tools like build_chapter_delivery_packet or build_chapter_revision_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 usage is after acceptance ('post-acceptance'), but does not provide explicit when-to-use, when-not-to-use, or alternative tools. There are many 'build_' siblings, yet no guidance on choosing this one, leaving the agent without clear context selection criteria.

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

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

No annotations are present, so the description carries full burden for behavioral disclosure. It only states the tool builds context but doesn't explain what 'chapter-safe context' means, side effects, authorization needs, or data modifications. Details are insufficient.

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

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

The description is a single sentence, which is concise, but it omits critical information that could be included without verbosity. It is not a model of efficiency because it sacrifices 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?

Given the lack of output schema, annotations, and schema description coverage, the description should compensate by explaining the return value, behavior, and prerequisite steps. It fails to do so, leaving agents with significant ambiguity about what the tool produces and how to use 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%. The description adds no meaning to the parameters: it doesn't explain 'project_dir', 'chapter', or 'format' beyond what the schema already shows. The schema provides enum for format, but description offers no 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 uses specific verb 'build' and resource 'chapter-safe context', indicating it constructs context for a chapter. The phrase 'before writing or revising' adds context, but it doesn't differentiate from sibling tools like build_chapter_context_brief, which may overlap in 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 implies usage before writing or revising, but provides no guidance on when not to use the tool or which alternative to choose from the many sibling tools. Usage context is vague.

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 discloses the tool's read-first nature and target context, indicating a safe, non-destructive operation. However, it doesn't mention any side effects or 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 clear sentence, front-loading the core purpose. It is concise but could be slightly more informative without becoming verbose.

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 sibling tools and lack of output schema, the description adequately distinguishes the tool's niche but omits details on output format or limitations, making it minimally complete.

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

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

Schema description coverage is 0%, and the description adds no information about the three parameters (format, chapter, project_dir), leaving the agent to infer their meaning from names and schema constraints.

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

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

The description clearly states the tool builds a 'compact read-first chapter context brief' for 'small-context desktop agents', specifying the exact resource and differentiating from siblings like build_chapter_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 when a compact version is needed and for desktop agents, but does not explicitly state when not to use or name alternatives like the full build_chapter_context 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?

The description mentions 'read-only' which hints at non-destructive behavior, but with no annotations, it lacks explicit disclosure of side effects, permissions, or response format. It does not contradict any annotations since none exist.

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

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

The description is a single, efficient sentence with no redundancy. It conveys the core purpose concisely, though it could be slightly expanded for 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 5 parameters, no output schema, and no parameter descriptions, the description is incomplete. It does not explain the output format or the meaning of 'combined' in practical terms. The agent lacks sufficient information to use the tool effectively.

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 does not describe any parameters (file, format, chapter, project_dir, include_context) despite 0% schema coverage. It fails to compensate for the lack of schema descriptions, leaving the agent to infer parameter usage from the tool's purpose alone.

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 'Build' and the specific resource 'read-only author delivery packet'. It lists the components combined, distinguishing it from sibling tools like 'build_handoff_report' and 'build_chapter_readiness'.

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 for building an author delivery packet by combining various elements, but it does not explicitly state when to use this tool versus alternatives like 'build_handoff_report' or 'build_chapter_context'. No exclusions or alternative guidance 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?

Declares 'read-only' indicating a non-mutating operation, but lacks details on prerequisites, permissions, or side effects. With no annotations, description fails to sufficiently disclose behavioral traits.

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

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

Single sentence is concise but dense; could benefit from restructuring for clarity. No wasted words, but could be organized better.

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

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

For a tool with 4 parameters, no output schema, and no annotations, the description is insufficient. It omits details about the report's format, parameter semantics, and expected output behavior.

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 has 4 parameters with 0% description coverage, and the description provides no additional meaning for any parameter. The output mention of 'revision_plan' does not clarify parameter usage.

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

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

Description clearly states the tool builds a read-only author-facing chapter acceptance readiness report from continuity checks and contract diff. It specifies the output includes a revision_plan, distinguishing it from sibling tools like build_chapter_acceptance_plan, though not 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?

Implies usage for author's readiness check via 'author-facing', but no explicit when-to-use, when-not-to-use, or alternative tools are mentioned.

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

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

The description declares the tool is 'read-only' and produces a 'revision report', which implies no side effects. However, with no annotations provided, it lacks important behavioral details such as required permissions, error handling for missing files, or performance 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, straightforward sentence with no wasted words. It is front-loaded with the core action. However, it could be improved with structured formatting (e.g., bullet points) for better 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?

Without output schema or parameter explanations, the description leaves significant gaps. For a tool with 6 parameters and many siblings, the minimal contextual information is inadequate 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%, yet the description adds no meaning to any of the 6 parameters (project_dir, chapter, before_file, after_file, format, include_context). Users must infer their purpose from names alone, 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 clearly states the tool's function: 'compare before and after draft readiness for a read-only revision report with resolved, new, and remaining issues.' It uses a specific verb ('compare') and resource ('draft readiness'), and distinguishes from sibling tools like 'build_chapter_readiness' and 'diff_chapter_contract' by focusing on revision 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 provides no guidance on when to use this tool versus alternatives. Despite many sibling tools, it fails to mention any exclusions, prerequisites, or contextual cues for selection.

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

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

The description states the tool is 'read-only' and 'copyable', which implies no state modification. However, no annotations are present, so the description carries the full burden. It does not disclose potential side effects, prerequisites, or output behavior beyond being a prompt.

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 of 14 words, front-loading the main action. It is concise, though the use of unqualified jargon slightly reduces clarity. Every word serves a purpose, making it 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?

Given the tool has 5 parameters (3 required) and no output schema or annotations, the description is insufficient. It lacks details about the prompt's format, how the 'local desktop agent' uses it, and the role of each parameter. More context is needed for proper 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 fails to explain any of the five parameters. Terms like 'chapter readiness', 'revision_plan', and 'fact_context' are mentioned but are not parameter names. The meaning of 'file', 'format', 'include_context', etc., remains 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 clearly specifies the verb 'Build', the resource 'revision prompt', and the input sources (chapter readiness, revision_plan, fact_context). It distinguishes this tool from siblings like 'build_chapter_context' by focusing on revision prompts. However, it could be more specific about the output format or use case.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. Among siblings like 'build_chapter_context' and 'build_chapter_readiness', the agent must infer the appropriate context without any usage notes 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?

Description labels the tool as 'read-only', which is helpful, but fails to disclose other behavioral traits such as permissions required, side effects, or how parameters affect output. With no annotations, the burden on description is high and unmet.

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?

Description is a single sentence, achieving conciseness but lacking structure or additional details. It is minimally viable but not optimally efficient given the 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?

With 10 parameters, no output schema, and no annotations, the description is insufficient. It does not explain parameter combinations, return content, or preconditions, leaving the agent inadequately informed.

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 description adds no explanation for any of the 10 parameters. Only 'optional pack health' is alluded to but not mapped to a specific parameter. Agent receives no semantic guidance beyond the schema's names and types.

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

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

Description explicitly states verb 'Build', resource 'desktop-agent diagnostics report', and sources from project state, MCP config, desktop evidence, and optional pack health. It clearly distinguishes from sibling tools which focus on chapters, proposals, or other specific areas.

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 guidance on when to use this tool versus alternatives. The description implies a diagnostics use case but does not specify conditions, prerequisites, 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, the description must disclose behavior. It indicates 'read-only' (no side effects) and inputs, but fails to mention response format, performance, or any constraints. Lacks detail on what the tool does beyond building a report.

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 18-word sentence, which is concise but at the cost of necessary detail. It is front-loaded with key info but insufficient for a complex 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 9 parameters, 4 enums, no output schema, and no annotations, the description is severely incomplete. It does not explain return values, parameter effects, or provide enough context for effective use.

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 description does not mention any of the 9 parameters (mode, format, platform, etc.). No explanation of what each parameter controls, leaving the agent unable to set them 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 clearly states the tool builds a 'read-only next-step decision report' for a local desktop agent, specifying the sources. It distinguishes from siblings by emphasizing 'read-only' and 'local desktop agent', but not all siblings are fully differentiated.

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

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

No explicit guidance on when to use this tool versus the many sibling tools (e.g., build_agent_activity_report, build_desktop_diagnostics). The description does not provide when-not-to-use or alternative tools.

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

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

The description adds context about the report's contents but does not disclose behavioral traits such as whether it modifies state, requires specific permissions, or has side effects. Since no annotations are provided, the description partially fills the gap but is insufficient.

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

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

The description is a single sentence that conveys the core function efficiently. While it could be slightly restructured to highlight key points earlier, it is concise and readable.

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

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

For a tool with three parameters and no output schema, the description lacks essential details about parameter semantics, return values, and usage context. It does not enable an agent to use the tool autonomously.

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 explain any of the three parameters (chapter, project_dir, include_context). An agent would not know their meanings or how to use them 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 clearly states the tool's purpose: building a handoff report and next-agent brief, listing specific contents. It distinguishes from sibling tools like build_agent_activity_report and build_chapter_context, which cover different topics.

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

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

No guidance on when to use this tool versus alternatives. It does not specify prerequisites, context of use, or when not to use it among the many sibling build tools.

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

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

The description labels the tool as 'read-only', which suggests no side effects, but lacks details on what the readiness gate entails (e.g., checks performed, error behavior, or output structure). With no annotations, the description fails to adequately disclose behavioral traits.

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 key action and context. It is appropriately sized but could benefit from brief parameter explanations without becoming lengthy.

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 4 parameters (one required, one enum, a nested object) and no output schema, the description is too brief. It does not explain how results are returned or what constitutes a successful readiness check, leaving significant gaps for an AI agent.

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

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

Schema description coverage is 0%, so the description should compensate. It mentions 'saved or inline' proposals, vaguely linking to 'proposal_id' and 'updates', but does not explicitly define any parameter's role. The enum for 'format' and the nested object are 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 the action ('Build') and the resource ('readiness gate for a saved or inline post-write proposal before durable apply'), which is specific enough to distinguish from siblings that deal with chapters or reports. However, the term 'readiness gate' is somewhat abstract, leaving some ambiguity about the exact output.

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

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

No guidance is provided on when to use this tool versus alternatives like 'validate_proposal' or 'build_proposal_review'. The context of 'before durable apply' is implied but not explicitly stated as a usage 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?

The tool is described as read-only, which is a key behavioral trait, but no annotations exist. The description does not disclose error handling, side effects, or behavior for invalid inputs, leaving gaps in 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 concise at 13 words, but it sacrifices necessary detail. While front-loaded, it is too brief to fully inform usage, balancing conciseness with completeness poorly.

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 4 parameters including nested objects, no output schema, and no annotations, the description is highly incomplete. It lacks information on return values, error cases, and parameter relationships.

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

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

With 0% schema description coverage, the description fails to explain any of the four parameters (project_dir, format, updates, proposal_id). It adds no meaning beyond the schema, making it difficult for an agent to use 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 clearly states the tool builds a read-only author review packet for proposals, using a specific verb and resource. However, it does not differentiate from sibling tools like build_proposal_readiness or build_proposal_template, which could lead to confusion.

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

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

No guidance is provided on when to use this tool versus alternatives, nor are there any prerequisites or exclusions mentioned. The description lacks context for appropriate usage.

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 full burden for behavioral disclosure. It states the tool builds a template but does not explain side effects (e.g., file overwrite, directory requirements) or the nature of the template content (e.g., format, structure). No contradictions with annotations.

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

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

The description is a single sentence of 12 words, which is concise and front-loaded with the key purpose. While it lacks structure (e.g., bullet points), it is not verbose and every word adds 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?

Given 3 parameters, no output schema, and many sibling tools, the description is insufficient. It does not clarify the template's output format, evidence requirements, or how the parameters influence the result, leaving significant gaps for correct use.

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 explain any of the three parameters (file, chapter, project_dir). The agent receives no help in understanding what each parameter provides or how to use them 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 specifies the verb 'Build' and the resource 'empty post-write proposal template with chapter context and evidence requirements', which clearly distinguishes it from sibling tools that build chapter contexts or proposal readiness. However, 'post-write' is not defined, 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?

No guidance is provided on when to use this tool vs. alternatives like build_chapter_context or build_proposal_readiness. The description does not mention prerequisites, typical use cases, or when to avoid using 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 exist, so description must carry full burden. It mentions the tool returns issues and a revision_plan but does not disclose whether it modifies any data, requires permissions, or has side effects. For a 'check' tool, read-only behavior is implied but not 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?

The description is a single sentence, making it concise, but the long list of checks is dense and could be better structured for readability. It is not overly verbose but could be improved for 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's complexity (checking many aspects) and lack of output schema, the description is incomplete. It does not specify the format or structure of returned issues or the revision_plan, nor does it explain the checks in sufficient detail for an AI agent to fully understand the tool's capabilities.

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?

Input schema has three parameters with zero descriptions (0% coverage). The description does not explain any of the parameters (project_dir, chapter, file) beyond listing the tool's overall function, leaving the agent to infer their meaning and constraints.

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

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

The description clearly states the tool's purpose: checking a chapter file against multiple specific criteria and returning issues plus a revision plan. The verb 'check' and resource 'chapter file' are specific, and the list of checks differentiates it from sibling build 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?

No guidance on when to use this tool versus alternatives. With many sibling tools like build_chapter_readiness or build_chapter_acceptance_plan, there is no explicit differentiation or usage context 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?

The description states it is 'read-only' and performs specific checks. Without annotations, this is the primary behavioral disclosure. However, it does not explain failure behavior, return format, or required permissions, leaving gaps in 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 two sentences, front-loaded with key information, and contains no unnecessary words. It efficiently conveys the core purpose.

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

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

Given 6 parameters, no output schema, and 0% schema coverage, the description is incomplete. It does not describe the return value (e.g., pass/fail, error details) and only partially covers parameter semantics, making it insufficient for an agent to use correctly without additional context.

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

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

With 0% schema description coverage, the description must explain each parameter. It mentions three (expected_project_id, expected_state_sha256, expected_context_hash) but omits others like 'format', 'chapter', and 'project_dir'. The required 'project_dir' is not explained, limiting usefulness.

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 is a 'Read-only preflight' that checks project_id, state sha256, and optional chapter context hash. It identifies the resource (.novel-agent state) and the action (checks). However, it does not explicitly differentiate from sibling tools like 'check_chapter', 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?

The phrase 'before writer tools mutate .novel-agent state' implies when to use this tool. However, it does not specify when not to use it or mention alternative tools for similar checks. The guidance is implied 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?

No annotations are present, so the description bears full responsibility for behavioral disclosure. It states the tool performs a comparison but does not specify side effects, permissions, or whether it is read-only. The return format or potential errors are not addressed.

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

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

The description is a single, efficient sentence that front-loads the action. It avoids repetition and every word contributes meaning. Minor improvement could be structuring with bullet points for clarity, but current form is acceptable.

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 3 parameters with no schema descriptions, no output schema, and no sibling differentiation, the description is insufficient. It does not explain return values, error conditions, or how the comparison results are structured. The tool's complexity suggests a need for more detail.

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

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

Schema description coverage is 0% (no parameter descriptions), so the description must compensate. It adds context about what is compared (beats, checks, moves, markers) but does not explain the parameters 'file', 'chapter', or 'project_dir' (e.g., how 'file' relates to the chapter file). Baseline is 4; partial compensation reduces to 3.

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's action: 'Compare a chapter file with visible required beats, acceptance checks, forbidden moves, and future markers.' It identifies the specific resource (chapter file) and the aspects being compared, distinguishing it from siblings like 'diff_proposal' which deals with proposals.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, or typical use cases, leaving the agent to infer context from the sibling names alone.

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

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

With no annotations, the description carries the full burden. It implies a read-only preview but does not explicitly state side effects, permissions, or limitations. The verb 'Preview' suggests non-destructive behavior, but confirmation is absent.

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

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

The description is a single, efficient sentence that front-loads the verb and resource. It could include more detail without becoming overly long.

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?

Without an output schema, the description should explain the return value (e.g., diff format). It only states what will be previewed, missing crucial details about output and parameter semantics for effective 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 adds no meaning to the three parameters (updates, project_dir, proposal_id). The 'updates' object parameter is especially opaque.

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

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

The description clearly states the verb 'Preview' and the resource 'proposal', and specifies the aspects (facts, characters, debts, handoff fields) it examines. This distinguishes it from sibling tools like 'validate_proposal' or 'build_proposal_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?

No guidance is provided on when to use this tool versus alternatives. The description does not mention prerequisites, exclusions, or explicit usage context.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It only states a health check but does not explain side effects, authentication needs, or what 'state health' entails.

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, which is concise, but it is under-specified. Conciseness sacrifices critical information about parameters and behavior.

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

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

Given the tool has 3 parameters, no output schema, and no annotations, the description is too vague to enable correct invocation. It lacks details on return values, side effects, and parameter semantics.

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

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

Schema coverage is 0%, yet the description does not clarify the three optional parameters (project_dir, install_config, start_mcp_test). It loosely references 'kit installation' and 'state health' but provides no mapping to parameters.

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

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

The description uses a specific verb 'Check' and identifies the resources 'kit installation' and 'project .novel-agent state health'. While 'kit' is somewhat vague, it distinguishes the tool from siblings like 'check_chapter' and 'check_write_session'.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or contextual cues for selection.

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

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

No annotations are provided, so the description carries full responsibility. However, it does not disclose behavioral traits such as read-only nature, error handling, permissions required, or side effects. The brief description leaves much to the agent's inference.

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 action verb. No unnecessary words. However, it could be slightly more structured to enumerate the 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?

Given the tool has 4 parameters, no output schema, and no annotations, the description is insufficient. It does not specify the return format (despite a 'format' parameter), expected output, or behavior for invalid input. The description leaves significant gaps for effective 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?

With 0% schema coverage, the description must compensate. It mentions 'mode' and 'tool_profile' concepts but does not explicitly list or explain the parameters 'tool_name' and 'format'. The description adds some meaning beyond the schema but is incomplete for all four parameters.

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

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

The description clearly states the verb 'Explain' and the resource 'local MCP tool visibility', and specifies the dimensions (mode and profile). It is specific and unambiguous, with no sibling tools serving a similar 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 provides no guidance on when to use this tool versus alternatives, nor does it mention prerequisites or context. It merely states what it does without any usage direction.

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 full burden for behavioral disclosure. It merely states 'Return' implying a read operation but does not mention idempotency, side effects, authentication needs, or whether the instructions are static or dynamically generated. This is insufficient for safe agent usage.

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

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

Single sentence of 14 words is very concise and front-loaded. However, it could be slightly expanded to cover parameter details without losing conciseness.

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 output schema and no annotations, the description does not explain what the tool returns (e.g., format, structure of instructions), default behavior when optional parameters are omitted, or any error conditions. Incomplete for effective use.

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 description must explain parameters. It references 'local platform and write mode' loosely aligning with the two parameters, but does not clarify that 'writer' corresponds to 'write mode' or explain the meaning of each enum value. The description adds minimal value beyond the enum names in the schema.

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

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

Description specifies verb 'Return' and resource 'host desktop agent workflow instructions', indicating the tool retrieves instructions filtered by platform and mode. It distinguishes from sibling 'build_*' tools which generate rather than retrieve. However, 'workflow instructions' is somewhat vague.

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

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

No explicit guidance on when to use this tool versus alternatives like the many 'build_*' siblings. The purpose is implied but not contrasted with other tools. No prerequisites or when-not-to-use conditions are stated.

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

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

No annotations are provided, so the description must cover behavioral traits. It only states 'summarize' with no info on side effects, permissions, or whether it's a read 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?

Single sentence, concise. Could be improved by front-loading the core action, but no unnecessary words.

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

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

Given the tool has 5 parameters, no output schema, and no annotations, the description is inadequate. It doesn't explain output format, readiness criteria, or parameter roles.

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 to the 5 parameters (format, chapter, platform, project_dir, install_config). It only mentions 'project'.

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 summarizes readiness of a .novel-agent project for desktop-agent writing. It uses a specific verb and resource, but lacks differentiation from sibling tools like build_chapter_readiness.

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

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

No guidance on when to use this tool versus alternatives. With many sibling readiness tools, explicit usage context is missing.

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 sole source for behavior. It discloses that the tool returns a JSON Schema, implying a read-only operation with no destructive side effects. This is sufficient for a simple getter.

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, complete sentence with no wasted words. It is front-loaded and concise.

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 no output schema, the description fully specifies the tool's functionality. It is complete for its simplicity.

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 zero parameters, so baseline is 4 as per guidelines. Schema coverage is 100% (vacuously), so description adds no extra meaning but meets expectations.

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 verb 'Return' and the resource 'JSON Schema for post-write proposal updates'. It distinguishes from sibling tools which are mostly about building reports or checking, making its 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 provides no guidance on when to use this tool versus alternatives. No context about prerequisites or exclusions is 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?

The description provides no behavioral details beyond the verb 'list'. With no annotations present, the agent has no information about side effects, permissions, or safety. It is implied to be read-only, but not 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?

The description is a single, clear sentence with no unnecessary words. It is appropriately concise for a simple list 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?

The description is too sparse for a tool with 6 parameters and no output schema. It does not explain what constitutes an 'activity' or 'handoff record', nor how to filter results. Additional context is needed for effective use.

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 does not mention any parameters, despite the schema having 6 parameters with 0% coverage. The agent gains no additional meaning about the purpose or syntax of parameters like limit, action, format, chapter, agent_id, or project_dir.

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 verb 'list' and the resource 'local desktop agent activity and handoff records', which distinguishes it from sibling tools that 'build' reports. However, it could be more specific about the scope of 'activity'.

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

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

No guidance is provided on when to use this tool versus alternatives like build_handoff_report or list_agent_capabilities. The description leaves the agent to infer usage context.

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

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

No annotations are present, so description must cover behavioral traits. It implies read-only with 'List' but does not confirm idempotency, mention permissions, error handling, or side effects. Very little 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 a single sentence, which is concise, but it omits necessary details. It is not overly verbose but could be better structured to include parameter context.

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

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

With one required parameter, no output schema, and no annotations, the description is insufficient. It does not explain what constitutes a capability declaration, output format, or any practical context for the agent.

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

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

Schema description coverage is 0% and the description adds no meaning to the required parameter 'project_dir'. It fails to clarify what this parameter represents or how it affects the output.

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

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

Description uses specific verb 'List' and resource 'host agent capability declarations', clearly indicating the tool's action and object. While it distinguishes from siblings like list_agent_activity by focusing on capabilities, it does not explicitly differentiate.

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

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

No guidance on when to use this tool versus alternatives, no prerequisites or exclusions provided. The single sentence only states what the tool does, lacking context for appropriate usage.

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; description lacks details on behavioral aspects such as sorting, pagination, or return format, which is a significant gap for a listing 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?

Single concise sentence front-loads the purpose, but misses opportunities to include essential parameter details.

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

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

No output schema and 4 parameters; description fails to explain return values, project_dir requirement, or the concept of 'facts', making it incomplete for confident 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?

Schema coverage is 0%. Description only explains 'chapter' and 'kind' filters, omitting 'project_dir' (required) and 'include_inactive', leaving key parameters 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?

Description clearly states the tool lists facts with optional filtering by chapter and kind, distinguishing it from sibling tools that build, check, or diff other entities.

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 guidance on when to use this tool versus alternatives, but the purpose is clear enough to imply usage for listing facts.

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 alone must convey behavioral traits. It indicates the tool is read-only ('visible') and lists unresolved items, but lacks details on permissions, rate limits, pagination, sorting, or what 'visible' means. The mix of item types is mentioned but not explained.

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 efficiently conveys the tool's purpose. However, it lacks structure (e.g., bullet points) to break down the list items or parameter usage. It is not verbose, but could better organize information for 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 description is incomplete for a list tool without an output schema. It does not specify the output format, structure of returned items, or whether the optional chapter parameter filters results. An agent lacks essential context to interpret the tool's response or use it effectively.

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

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

The input schema has two parameters (project_dir required, chapter optional) with 0% schema description coverage. The description does not explain what these parameters represent, how to use them, or any constraints. For example, it is unclear if 'chapter' filters the list, and 'project_dir' lacks format or meaning.

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

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

The description clearly states the tool lists 'visible unresolved plot debts, chapter contracts, conflicts, and the latest handoff,' which is a specific set of resources. The verb 'list' is precise, and the resource is well-defined, differentiating it from sibling tools that focus on building, diffing, or checking other aspects.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., list_facts, list_agent_activity). There is no mention of prerequisites, scenarios, or exclusions. The usage context is only implied by the verb 'list.'

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 fully disclose behavior. It only indicates 'read-only' but does not explain side effects, output format, or dependencies (e.g., project_dir). Insufficient for a complex 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?

Single sentence is concise and front-loaded with key action, but could be more structured (e.g., breaking into purpose and usage). Still 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?

With six parameters, no output schema, and no annotations, the description is too sparse. It does not define 'startup packet', explain parameter effects, or describe return value, leaving significant gaps for an AI agent.

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

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

Schema description coverage is 0%, yet the description adds no explanation of the six parameters. While some names are self-explanatory, the description fails to clarify their roles or constraints, missing a critical opportunity.

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 builds a 'read-only startup packet' for a desktop agent before drafting or revising a chapter, specifying verb, resource, and context, distinguishing it from sibling tools like build_chapter_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 before drafting or revising, but does not explicitly state when not to use or mention alternatives from the extensive sibling list. Guidance is present but minimal.

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 fully disclose behavioral traits. It states the validation purpose but does not mention whether the tool is read-only, idempotent, or what side effects (if any) occur. Critical details like permissions or error handling are omitted.

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

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

The description is a single sentence of 11 words, concise but lacking in structure. It front-loads the purpose but sacrifices valuable detail that could be added without significant length.

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

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

Given the tool has 3 parameters (one nested object), no output schema, and no annotations, the description is incomplete. It does not explain the validation outcome (e.g., success/failure indication), error formats, or how to interpret results, leaving significant gaps for the agent.

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

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

The input schema has 0% description coverage, and the tool description does not explain any parameters. The agent must infer from names like 'updates' (ambiguous) and 'project_dir' (clear). No guidance on format, constraints, or relationships is provided.

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

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

The description clearly states the tool validates a post-write update proposal for evidence and conflicts before applying it, specifying the verb 'validate' and the resource 'proposal' in a specific context. It distinguishes from sibling tools like 'build_proposal_review' or 'build_proposal_template' which focus on building or reviewing rather than validating.

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 before applying an update proposal but does not provide explicit guidance on when to use this tool versus alternatives like 'build_proposal_readiness' or 'diff_proposal'. No when-not-to-use or prerequisite conditions are mentioned.

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