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

With no annotations, the description must carry behavioral context. 'Get' and the listed return content imply a read-only operation, but the description does not explicitly address side effects, not-found behavior, or how id_or_conversation_id is resolved. It provides some transparency but leaves important behavior unstated.

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 filler. The primary action and returned content are front-loaded, making it easy to parse.

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

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

For a simple get-by-id tool, the description gives enough to start, but it omits query_limit semantics and any error or empty-result behavior. With no output schema or annotations, a bit more context would be needed for fully confident 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 only 50%, and the description does not explain query_limit at all. The required id_or_conversation_id is documented in the schema, but the meaning of query_limit (whether it limits prompts, notebooks, or something else) is left completely ambiguous.

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 and resource: 'Get one Warp conversation', clearly distinguishing it from sibling list_conversations. It also enumerates the returned content, so an agent knows exactly what this tool retrieves.

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 is given about when to use this tool versus alternatives such as list_conversations. The word 'one' implies single-item retrieval, but there is no stated precondition, exclusion, or comparison with siblings.

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

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

With no annotations provided, the description carries the full burden, and 'Read' transparently signals a non-mutating operation. However, it does not disclose error behavior for missing IDs, authentication needs, or the shape of the returned note.

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

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

The description is a single sentence with no filler; the action and target are front-loaded. Every word contributes 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?

Adequate for a simple single-parameter get tool, but because there is no output schema or annotations, the description should ideally hint at return contents or not-found behavior. It is functional yet minimal.

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 parameter id has zero schema-description coverage, and the description merely restates lookup is by id. It adds little beyond the schema property name and does not explain the id format, provenance, or how to obtain a valid id.

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

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

The description uses a specific verb ('Read'), names the resource ('handoff note'), and scopes to a single record ('one'/'by id'), clearly distinguishing it from sibling tools like list_handoffs and write_handoff.

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 'by id' implies the tool is for fetching a known handoff note, but the description provides no explicit when-to-use guidance or comparison to alternatives such as list_handoffs for cases where the ID is unknown.

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 burden of behavioral disclosure. It clearly indicates a read-only retrieval action, which is helpful, but it does not describe behavior for not-found cases, ambiguous name matches, or the shape of the returned memory. These are meaningful gaps for a tool with no output schema.

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

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

The description is a single, well-structured sentence with no filler. It front-loads the action and resource, then states the lookup key. Every word contributes to the agent's understanding.

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

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

For a one-parameter retrieval tool, the description is minimally sufficient, but it leaves out important operational details: what happens when the name substring matches multiple memories, whether the match is case-sensitive, and what the response looks like. Since there is no output schema, these gaps matter more.

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

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

Schema description coverage is 100%, so the parameter is already documented. The description restates that lookup is by 'numeric id or name' but adds no new semantic detail beyond what the schema already provides, such as matching rules or formatting.

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 ('Get'), a clear resource ('Warp saved memory'), and a precise selection method ('by numeric id or name'). It also says 'one', which distinguishes it from the sibling 'list_memories' without 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 description implies this tool should be used when a single memory is needed and an id or name is available. However, it does not explicitly explain when to prefer list_memories or search, nor does it mention any exclusions for ambiguous name substrings.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool can look up by multiple identifier types, which is useful, but it does not state what happens on ambiguity, missing resources, or what the return value looks like. For a simple read-only getter this is adequate but minimal.

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, direct sentence with no filler. The verb and resource are front-loaded, and the lookup scope is stated in a compact list. 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?

For a tool with one parameter and no output schema, the description gives enough context to make a correct call: retrieve a notebook by id, title, or document uid. It does not describe the response shape, but for a getter that is generally assumed, and the low complexity keeps the bar modest.

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% for the single parameter, so the baseline is 3. The description adds almost nothing beyond the schema—'document uid' roughly repeats 'ai_document_id', and 'id, title' is already present in the parameter description. No significant extra meaning 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 identifies the operation (get), the resource (a Warp notebook / plan), and the lookup keys (id, title, or document uid). It implicitly distinguishes itself from sibling tools like list_notebooks or get_memory by naming the unique resource type, but it does not explicitly contrast itself with any sibling.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or cases where another tool like list_notebooks or search would be more appropriate. The usage context must be inferred entirely from the tool name and description.

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

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

With no annotations, the description carries the full burden and does add one important behavioral limitation: 'Transcripts are not stored locally,' which usefully prevents callers from expecting full chat history. However, it does not disclose whether the operation is read-only, how 'recent' is defined, or how results are ordered/paginated.

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

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

The description is a single, front-loaded sentence with no filler. It names the action and resource, lists key returned fields, and appends a meaningful limitation in a compact way.

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

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

There is no output schema and no annotations, so the description must carry more weight. It covers the main returned fields and one key limitation, but omits parameter semantics (especially limit and query) and any detail about ordering, paging, or result format. Adequate for a simple list tool, but with clear gaps.

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 low at 33%, with only working_directory documented in the schema. The tool description adds no parameter-level meaning: limit and query are not explained, and the text focuses only on the output shape rather than how the parameters affect the result set.

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

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

The description states a specific verb ('List'), a clear resource ('Warp agent conversations'), and a scope ('recent'), while enumerating what is returned: title, first prompt, and linked plans. It is clearly distinct from sibling list tools like list_memories and list_notebooks, though it does not explicitly contrast with get_conversation.

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

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

No guidance is given about when to use this tool versus alternatives such as get_conversation or search. The word 'recent' implies recent-only scope, but there is no explicit when-not-to-use condition or pointer to sibling tools for full-detail retrieval.

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 burden of behavioral disclosure, but it only repeats the list semantics. It does not mention ordering, pagination, the default limit, whether results are filtered by recipient, or any side-effect expectations, leaving the agent to infer behavior from the schema.

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

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

The description is a single efficient, front-loaded sentence with no filler. It is concise, though the brevity comes at the cost of omitting usage and behavioral 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?

For a simple 2-parameter list tool this is close to adequate, but the absence of annotations, output schema, and any usage guidance leaves gaps in filtering behavior, result shape, and sibling-tool selection. A short phrase about when to use it or what the returned handoffs contain would make it 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 coverage is only 50%: to_agent has a schema description, but limit only has a type and default. The tool description adds no parameter meaning, so the semantics of limit rely entirely on its name and default value.

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

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

The description states a clear action ('List') and a specific resource ('Grok ↔ Oz coordination handoffs'), and the plural verb distinguishes it from singular get_handoff or mutating write_handoff. It doesn't explicitly call out sibling tools, so it stops short of full differentiation.

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

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

No guidance is provided about when to use list_handoffs rather than list_conversations, search, or get_handoff. The tool's purpose is implied only by its name and the verb, with no conditions or alternatives 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?

With no annotations, the description carries the behavioral burden. It clarifies the data source and scope ('local AIFACT remember this items'), which is useful, but it does not disclose return shape, pagination, or whether any implicit filtering or side effects occur.

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

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

The description is a single, front-loaded sentence with no filler. The parenthetical adds clarifying context without bloating the text.

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

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

For a simple list tool with one optional parameter, the description and schema together provide enough to invoke it correctly. A few gaps remain: no mention of what the returned entries look like and no explicit alternative routing, but these are minor for this operation.

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

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

The schema covers 100% of the single parameter with a clear description ('Optional filter on memory name or content'). The tool description adds no additional parameter meaning, so the baseline for high schema coverage applies.

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

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

The description uses a specific verb ('List') and a specific resource ('Warp saved memories'), and clarifies the exact scope with 'local AIFACT remember this items'. This distinguishes it from siblings like get_memory (single retrieval) and search (broader exploration).

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 intended use is implied: use this tool when you want to list saved memories. However, it does not explicitly mention when to prefer alternatives like get_memory or search, nor does it state when not to use this tool.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It indicates a read-only listing operation, but does not mention pagination, result limits, default snippet behavior, ordering, or whether the result is a flat list versus a tree.

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

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

The description is a single, front-loaded sentence with no wasted words. The parenthetical clarification about agent plans is useful context, though slightly informal.

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

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

The tool is simple with two optional parameters and full schema coverage, and the core purpose is clear. However, with no output schema and no annotations, the description does not fully cover return shape, pagination, or when to favor sibling tools, leaving the definition minimally viable rather than 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 100%, so the schema already documents both parameters well. The description adds no additional parameter-level meaning beyond what the schema provides, which matches the baseline score of 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 uses a clear verb and resource: 'List Warp Drive notebooks / agent plans.' It also adds context that full plans live in these notebooks, which helps an agent understand what the resource represents. It does not explicitly differentiate from sibling tools like search or get_notebook, so it stops short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives such as search, get_notebook, or list_memories. The description only states what the tool does, leaving the agent to infer the appropriate selection context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the operation (list) and the file paths, but does not describe whether it returns just names or full paths, whether it is read-only, or any limitations (e.g., top-level only). This minimal behavioral info leaves the agent guessing about the output and side effects.

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

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

The description is a single, front-loaded sentence that says exactly what the tool does with no wasted words. It clearly leads with the verb and resource, making it efficient and easy to parse.

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 the tool has no parameters and no output schema, the description is minimal but functional. It tells the agent what the list contains, but does not specify the return format (e.g., an array of paths, whether contents are included). For a simple list tool, this is adequate but leaves room for more detail on the response structure.

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

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

The tool has zero parameters, so the baseline is 4. The description adds context about what the list contains (the specific file paths), which is useful even though no parameters exist. It does not need to explain parameter behavior because there are none.

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

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

The description states a specific verb (List) and resource (Warp project rule files), and explicitly names the file paths (AGENTS.md / WARP.md). This clearly distinguishes it from sibling tools like list_memories or list_notebooks by focusing on project rules.

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

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

The description provides clear context that this tool lists project rule files, which tells an agent when to use it (whenever project-level rules are needed). However, it does not explicitly state when not to use it or mention alternatives, though the resource specificity largely makes that implicit.

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 burden. It discloses that results are recent and scoped to user prompts, but omits ordering, pagination, default limits, and whether it is read-only. This is adequate for a simple list tool but leaves notable gaps.

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

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

One concise, front-loaded sentence with no filler. It could contain more useful detail, but what is included is efficient and to the point.

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 four parameters, no annotations, and no output schema, the description is too thin. It fails to clarify how parameters affect behavior, what filtering is possible, or what the response contains. An agent would likely need to guess at important calling details.

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

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

Schema description coverage is only 25%, so the description should compensate. It does not explain limit, conversation_id, or working_directory meaning, relying only on parameter names. The description adds no real parameter-level value.

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

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

States a specific verb and resource: 'List recent user prompts sent to Warp / Oz.' It is clear what the tool returns, though it does not explicitly differentiate itself from siblings like list_conversations or search.

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 list_queries versus alternatives such as search or list_conversations. There are no conditions, exclusions, or preferred use cases provided.

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

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

No annotations are provided, so the description carries the full disclosure burden. It adds useful behavioral context: the search spans multiple sources and includes recent prompts, and it implies a read-only operation. However, it does not describe the output shape, result ordering, or whether any side effects occur.

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

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

The description is two tight sentences with no filler. The action and scope are front-loaded, and the usage guidance is packed into a compact, readable example.

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 cross-source search tool with no output schema, the description clearly defines what is searchable and when to use it. However, it omits any description of the return format and does not explain limit behavior, leaving the agent to discover those details by invoking the tool.

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 67% and the description enriches the sources enum by mapping memories, notebooks, conversations, and queries to 'Warp memories, notebooks/plans, conversation summaries, and recent user prompts to Oz'. It does not clarify the limit parameter beyond its schema default, so the added value is moderate but not exceptional.

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 ('Search') and names distinct resources: Warp memories, notebooks/plans, conversation summaries, and recent user prompts to Oz. It also gives concrete example queries, making the tool's purpose unmistakable and clearly distinguishing it from the single-source sibling list/get tools.

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

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

The description provides clear usage context by saying it is the 'best first tool' for questions like 'what did Oz work on' and 'find the Warp plan'. It does not explicitly state when not to use it or mention alternatives for targeted lookups, so it stops short of full when/when-not guidance.

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

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

With no annotations, the description carries the burden of behavioral disclosure. 'Describe' implies a non-mutating, read-only operation, and the object clarifies that it reports a local-versus-cloud availability summary. However, it does not mention response format, dependencies, side effects, or why it should be used first, leaving some behavioral context implicit.

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

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

The description is two short sentences with the primary purpose front-loaded. The second sentence adds actionable guidance without redundancy, and no filler words are present.

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

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

For a zero-parameter status tool with no output schema, the description conveys what the tool reports and when to use it. Minor ambiguity around 'Warp / Oz data' and 'readable' remains, but an agent has enough information to invoke the tool correctly.

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

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

The tool has zero parameters and schema description coverage is 100%, so there is nothing for the description to add about parameters. This matches the baseline for a parameterless 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 states a specific action ('Describe') and resource ('what Warp / Oz data is readable locally versus cloud-only'), making the tool's scope clear. It also differentiates from the sibling entity-specific tools by focusing on data availability rather than listing or retrieving a particular record type. 'Describe' is slightly soft as a verb, but the object is precise.

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 explicit instruction 'Use this first when coordinating with Warp's AI' gives a clear trigger for when to invoke this tool. It does not name alternatives or exclusions, but the sibling tools are clearly different in purpose, and the precedence cue provides practical routing guidance.

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

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

With no annotations, the description must carry the behavioral burden. It discloses the storage location ('Stored under ~/.warp/agent-coordination/handoffs (not in warp.sqlite)'), which is a useful detail, but it does not mention side effects, idempotency, return values, or error conditions. For a mutation tool with zero annotation coverage, this 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, efficient sentence with no filler. It front-loads the purpose and adds the storage detail, which is useful. It is concise without being verbose, though the brevity contributes to the lack of information in other dimensions.

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

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

For a write tool with 7 parameters, no output schema, and no annotations, the description is severely incomplete. It lacks any explanation of parameter meanings, return behavior, or usage context. An agent would be unable to correctly construct a call without additional prior knowledge or guesses.

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 offers no descriptions for any of the 7 parameters. The description does not mention any parameters at all, so it adds no meaning beyond the parameter names, which are ambiguous (e.g., to_agent, related_notebook_id). The agent cannot determine what values to provide or what each parameter signifies.

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 (write) and the resource (coordination note), and adds the storage location, which helps distinguish it from the read-only siblings like list_handoffs and get_handoff. However, it does not explicitly use the term 'handoff' to align with sibling naming, so it is clear but not perfectly explicit about the relationship.

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

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

The description gives no explicit guidance on when to use this tool versus the read-only siblings. The contrast is only implicit: it writes while the siblings read. There are no mentions of alternatives, exclusions, or typical scenarios, leaving the agent to infer the usage context.

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