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

Despite no annotations, the description explains key behaviors: outcome summary is the 'most valuable artifact', the uncommitted flag escalates collision warnings, and it instructs to omit unknown fields. It does not address reversibility or permissions, but overall provides substantial behavioral context.

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

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

Single dense paragraph, front-loaded with purpose, then outcome guidance, then git facts. Every sentence contributes essential operational detail; no filler.

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

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

For a tool with 6 params and no output schema, the description explains the purpose of each param in operational context and the workflow. It stops short of describing the tool's return value or post-conditions, but that may not be needed.

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

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

Schema covers all parameters with descriptions, but the description adds practical guidance: how to gather files via git diff, what uncommitted means for other agents, and that outcome should cover 'what actually changed, surprises, dead ends'. A minor ambiguity: says outcome required for 'done' while schema requires it always.

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 opens with 'Close out an intent when work finishes or is abandoned' — a specific verb+resource+scope. It clearly distinguishes from sibling tools like post_intent (create) and update_intent (modify).

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?

States explicitly when to use: 'when work finishes or is abandoned'. However, it does not mention alternatives or exclusions, relying on sibling names to disambiguate.

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. It thoroughly discloses behavior: how q matches per-word (all words must appear, any order), AND-combination of q and overlaps, the effect of match='any', alert_level values when overlaps is given, and the purpose of each parameter mode. No contradictions exist between description and annotations (none provided).

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

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

The description is well-structured with numbered use cases and clear separation, but it is quite lengthy. While every sentence adds value, it could be slightly more concise by integrating the alert_level explanation into the use case descriptions. Overall, it is well-organized but not maximally 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 13 parameters, no output schema, and no annotations, the description covers the three distinct use cases thoroughly and explains parameter interactions. However, it does not describe the return format beyond mentioning 'alert_level.' Without an output schema, a brief note on the fields returned (e.g., summary, kind, status, author) would improve completeness.

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 high (92%), but the description adds significant meaning beyond individual parameter descriptions: it explains the three usage patterns, how parameters interact (e.g., summary enables semantic checks, overlaps triggers alert levels, q and overlaps are AND-combined, omit q for collision checks), and provides real-world context for parameters like session, branch, and my_kind.

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

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

The description opens with 'Query in-flight and recent work across the team,' clearly stating the action and resource. It then enumerates three distinct use cases, each with a specific purpose, effectively distinguishing this read-only tool from its siblings (post_intent, update_intent, etc.).

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 explicitly instructs the agent to 'pick exactly one' of the three use cases and provides concrete guidance on when to use each: pre-planning semantic check (summary + overlaps), fast glob collision check (overlaps alone), and context search (q + since). It also warns against combining q with overlaps incorrectly and explains when to omit q, offering exceptional decision support.

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 clearly discloses that the tool is idempotent, never rewrites the completion record, and that providing commit SHAs is optional ('pass the commit SHAs if you know them; landing without them is fine and complete'). It also explains behavioral nuance ('the tree it cannot see is the one thing it cannot check for itself').

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 paragraph that front-loads the core action ('Record that work... is now in git'), then adds context about when and why to call it. Every sentence contributes meaningful information — no redundancy or filler.

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

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

Given that there is no output schema and no annotations, the description covers the tool's purpose, usage cues, behavioral traits, and parameter guidance comprehensively. The tool has low complexity (2 params, 1 required), and the description provides everything needed for an agent to select and 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 100%, so baseline is 3. The description adds value beyond the schema by explaining the purpose of the `commits` parameter in context ('if you know them. Omit if you don't — do not guess'), and emphasizes that the timestamp is the correction when commits are unknown. This added guidance justifies above baseline.

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

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

The description uses specific verbs ('Record', 'mark', 'landed') and clearly identifies the resource ('work an already-COMPLETED intent declared uncommitted is now in git'). It distinguishes this tool from siblings like complete_intent (which marks intent completion) and post_intent (which creates a new intent) by focusing on the post-completion git state update.

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 explicitly states when to call this ('the moment you learn it') and provides clear examples ('you committed and pushed that work yourself, or you can see in the tree that the work another session left uncommitted has since landed'). It explains the consequences of not calling it ('registry keeps warning', 'keeps re-telling the same story'), which strongly implies when it should be used.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It comprehensively explains what the tool returns (intent id, overlapping intents with severity levels warn/nudge/fyi, and context of recent work), how to interpret collision signals, and that decision intents are stored as complete and never collide. It also notes the requirement to keep the intent id for posting outcomes later. No contradictions 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 lengthy but every sentence adds important context for correct tool usage. It is structured with clear explanations for inferred parameters and return value handling. While it could be slightly more terse, the density of actionable information justifies its length. The guidance is front-loaded with the core purpose and when to call.

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

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

Despite having no output schema, the description thoroughly explains the return values (id, overlaps with severity, context) and how to act on them. It covers all 7 parameters with extra context, including required fields and special handling for decisions. For a complex tool with 3 required params and behavioral nuance, the description is complete enough for an AI agent to use correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds significant value beyond the schema by explaining how to infer 'kind' (build/explore/spike/decision with usage rules), how to derive 'repo' consistently, what 'title' should look like (like a commit subject ≤80 chars), and that 'outcome' is only for decisions. It also offers guidance on 'summary' as a one-paragraph explanation. This extra context raises the score above baseline.

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

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

The description clearly states the tool's purpose: 'Register what you are about to work on so other developers' agents can avoid collisions.' This is a specific verb (register) on a specific resource (intent). It distinguishes from sibling tools like list_intents, update_intent, complete_intent, and mark_intent_landed by focusing on creation and registration of new work intentions.

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 explicit guidance on when to use the tool: 'Call this before starting any non-trivial coding task (anything touching more than a trivial fix).' It also explains how to infer the 'kind' and 'touches' parameters, and for decisions, it clarifies that no complete_intent is needed. However, it does not explicitly state when not to use it or list alternative tools for specific scenarios, so it stops short of a 5.

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

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

No annotations were provided, so the description carries full burden for behavioral disclosure. It excellently covers key behaviors: the collision-check dependency on stale globs ('stale globs silently miss real collisions'), the TTL heartbeat mechanism with explicit expiry ('active intents expire after ~48h without one'), the side-effect of returning fresh overlaps when calling with just the id, and the importance of treating 'warn' responses seriously. This is comprehensive for a mutation tool.

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

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

The description is compact yet dense with information, using front-loaded key points (verb, resource, when-to-use) then expanding logically. Every sentence adds substantive value: purpose, use-cases, side-effect, warning, and explicit exclusion. No redundancy or filler. It efficiently uses punctuation (semicolons, dashes, parentheses) to pack information without 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?

Given the complexity of this tool (5 parameters, mutation, TTL-aware, collision-sensitive) and the absence of an output schema, the description is remarkably complete. It covers all critical aspects: usage triggers, parameter semantics, side-effects (overlaps, warn), failure modes (stale globs), lifecycle (TTL expiry), and what not to do (complete_intent). The description fully compensates for missing annotations and output schema.

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

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

Schema description coverage is 100%, so the baseline is 3. However, the description adds significant meaning beyond the schema: it explains the impact of stale globs on collision detection ('collision checks run against these fields'), clarifies that calling with just the id 'returns fresh overlaps' (a behavioral side-effect not in any parameter description), and gives real-world time context ('~48h'). This elevates the score well above baseline.

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

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

The description clearly states 'Update an in-progress intent' as the primary purpose, with specific verbs (update, revise, renew) and resources (summary, touches, TTL). It distinguishes itself from 'complete_intent' by explicitly stating 'Never use this to finish work — call complete_intent for that.' This matches the sibling list and provides clear differentiation.

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

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

The description provides explicit guidance on when to use the tool: 'Call when the work changes shape' (revise summary or touches) or 'when work runs long' (renew TTL heartbeat). It also states what NOT to do ('Never use this to finish work') and points to a sibling alternative ('call complete_intent for that'). Additionally, it warns about treating a 'warn' response similarly to post-time checks, giving clear behavioral context.

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