totem-mcp

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

Annotations are absent, so the description carries full behavioral disclosure responsibility. It only says 'Create', implying mutation, but does not disclose side effects, idempotency, permissions, or failure modes. This is a significant gap 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?

Two sentences with no waste, but the structure is flat and does not organize information (e.g., parameter descriptions, usage context). It is concise but under-specified rather than well-structured.

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

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

Given the tool's complexity (9 parameters, 6 required, no schema descriptions) and no annotations, the description is grossly insufficient. It only addresses one parameter and provides no context on return values, typical usage, or differentiation from sibling memory tools.

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

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

Schema coverage is 0%, so the description must compensate for all 9 parameters. It only explains the 'impact' field (values and blocking semantics). The other required parameters (title, statement, tags, question, interpretations) and optional ones are completely undocumented, leaving agents to guess their content and format.

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 clear verb and resource ('Create an ambiguity memory'), which is specific enough. However, it does not differentiate from sibling tools like assumption_create or gotcha_create; an agent cannot tell when this is the right choice without more 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?

No guidance on when to use this tool versus alternatives. The impact parameter note ('high/critical = blocking') hints at a decision factor but does not explain when an ambiguity memory is appropriate compared to other memory types.

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 of behavioral info. It implies a write operation (create), which is somewhat transparent, but it does not disclose side effects, required permissions, or whether the operation is reversible. This is a moderate level of 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 extremely concise and to the point, containing only the essential information about the tool's purpose. There is no fluff or redundant wording, 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 the tool's complexity (11 parameters, no annotation coverage), the description is severely lacking. It does not explain what an 'architecture memory' is, how to fill the required fields, what the output will be, or how this fits into the broader context. A minimal viable description would need to provide at least basic parameter guidance.

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

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

The schema has 11 parameters, yet the description provides no explanation of what any parameter means or how they relate to 'component structure mapping.' Since schema coverage is 0%, the description adds no value for understanding the parameters, leaving users to infer their purpose 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 action (create) and the resource (architecture memory), making the purpose understandable. However, it does not differentiate this tool from sibling tools like memory_create_tool or gotcha_create, so ambiguity remains about when to prefer this specific tool.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The description does not mention criteria for selecting this tool over siblings, nor does it provide any usage context beyond the basic creation action.

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 information is provided about side effects, persistence, or any mutating behavior. Since no annotations are available, the description carries full responsibility but fails to disclose what happens when an assumption memory is created (e.g., whether it is stored, linked, or validated).

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

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

The description is very short, but it is not effectively concise because it omits essential information. It spends characters on an unclear 'classify' fragment rather than providing useful structure or context. The brevity is not paired with 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 lacks crucial context that an agent needs to correctly invoke the tool. It does not explain the domain, the expected input format, the relationship to other memory types, or any output expectations. Given the tool's placement among many similar creation tools, this is a critical gap.

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

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

None of the eight parameters are described. The schema provides only field names and types, but the description does not explain the meaning of fields like 'statement', 'claim_category', 'basis', or how 'verification_needed' should be used. The 'classify' hint is the only semantic clue and is incomplete and confusing.

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 ('Create an assumption memory') and identifies the resource type, but it does not clarify what qualifies as an 'assumption' or how this tool differs from sibling memory creation tools like hypothesis_create or observation_create. The lowercase 'classify' hint is ambiguous and does not provide meaningful purpose.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention any criteria for selecting this tool over similar creation tools, nor does it offer examples or context for appropriate use.

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

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

No annotations are provided, so the description carries the full burden. It discloses the state machine (open→confirmed→fixed→verified) but does not mention whether creation is destructive, what is returned, or any side effects. This is minimal behavioral disclosure for a creation tool.

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

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

The description is a single sentence plus a state machine, front-loading the core purpose with zero wasted words. It is extremely concise and well-structured.

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 11 parameters, 5 required, and no annotations, the description is inadequate. It does not explain how parameters relate to the state machine, what the expected outcome is, or how to handle optional fields. Even with an output schema, the description leaves too much unspecified.

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

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

Schema description coverage is 0% and the description mentions none of the 11 parameters. The schema itself has clear names (title, symptom, severity, etc.), but the description adds no semantic context, leaving the agent to infer everything from the schema 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 verb 'Create' and the resource 'bug memory', and the state machine adds specific context. It distinguishes from sibling tools like gotcha_create and rejected_idea_create by targeting bugs.

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 name and state machine imply bug tracking, but there is no mention of use cases, exclusions, or preferred scenarios.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that the tool creates something, implying a mutation, but does not disclose side effects, idempotency, permissions, or failure behavior. The output schema exists but is not referenced, and the description adds no transparency beyond the basic create action.

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 states the core purpose without redundancy. It is front-loaded with the action and object, and every word earns its place. There is no fluff or unnecessary detail, making it exemplary in 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?

For a tool with 8 parameters, no schema descriptions, and no annotations, this description is severely incomplete. It lacks guidance on parameter usage, return values, when to use this tool over siblings, and behavioral expectations. An agent would be unable to correctly construct a call without additional external knowledge. The description is far too minimal for the tool's complexity.

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

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

Schema description coverage is 0%, so the description must compensate for the lack of parameter documentation. However, the description does not mention any parameters, their meanings, or relationships. The schema itself has no descriptions, leaving the agent to guess from property names like 'statement', 'constraint', 'severity', etc., which is inadequate for correct invocation.

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 verb ('Create') and resource ('constraint memory') with a specific purpose ('implementation restrictions'), which distinguishes it from generic memory creation. However, it does not explicitly differentiate from sibling create tools like invariant_create or assumption_create, leaving some ambiguity about what makes a 'constraint' unique.

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. It does not mention any exclusions, prerequisites, or selection criteria. An agent must infer from the name and the phrase 'implementation restrictions' when this tool is appropriate, which is insufficient for a set of many similar memory-creation 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?

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only states the action and purpose but does not mention side effects, idempotency, permissions, or what happens to existing data. This is a significant gap 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 a single, front-loaded sentence that directly states the tool's purpose without waste. It is appropriately concise, though it sacrifices essential detail for brevity.

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 11 parameters, zero schema descriptions, and no annotations, the description is severely incomplete. It fails to explain what each parameter means, how to structure a contract, or what constraints apply. An agent cannot correctly invoke this tool with the provided information.

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 is the only source of parameter meaning. Yet it does not explain any of the 11 parameters (title, statement, tags, subject, inputs, outputs, etc.) or how they relate to 'observable behavior.' The description adds no value beyond the schema's bare field names.

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

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

The description clearly states a specific action ('Create a contract memory') and its purpose ('for observable behavior of functions/APIs'), which differentiates it from sibling memory types like bug, decision, or assumption. However, it does not explicitly contrast with any sibling tool, so it earns a 4 rather than a 5.

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

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

The description gives no guidance on when to use this tool versus the many sibling creation tools (e.g., bug_create, decision_create). It does not mention any prerequisites, exclusions, or alternative tools, leaving the agent to infer usage from the type name alone.

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

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

With no annotations provided, the description carries the transparency burden. 'Create' implies persistence, and the rationale requirement is stated, but side effects, failure modes, and whether it overwrites or rejects duplicates are not disclosed.

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 extremely concise and direct, using only two sentences and no filler or redundant detail.

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

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

The description lacks parameter definitions, return-value expectations, and any usage context about when decision memories are appropriate. Though an output schema is indicated as present, the description itself provides minimal context beyond the core creation action.

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

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

The schema has zero description coverage, and the description does not define the parameters. While names like title, tags, and rationale are self-explanatory, fields such as statement, details, project, and especially alternatives remain ambiguous—alternatives is an array of string-valued objects with no explanation of its intended structure.

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 creates a decision memory, using the specific verb 'Create' and the resource 'decision memory'. This distinguishes it from the many sibling create tools for other memory types.

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

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

It gives one useful usage directive: 'Always provide rationale explaining WHY.' However, it does not explicitly indicate when to prefer this tool over generic memory_create_tool or other specialized create 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 reveals a read-like operation through its pipeline (match, score, sort, truncate) and explicitly states that conflicts and warnings are never dropped for budget, which is a notable behavior. However, it does not mention side effects, whether it modifies any state, or what happens on errors, and the absence of annotations places the burden on the description.

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 brief and to the point, containing a concise pipeline overview and parameter explanations. It avoids redundant elaboration and front-loads the core behavior, making it easy to scan.

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 omits critical information about the output format (e.g., what 'serialize' returns, the structure of results) and does not mention error handling or edge cases. An agent may be unsure what to expect from the tool beyond a generic 'context' assembly, limiting complete usability.

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?

Each parameter is described in the prose listing (e.g., 'tags: Tags to match against', 'include_stale: Whether to include potentially stale items'), which adds clarity beyond the bare schema. Some descriptions are terse (e.g., 'types' and 'paths' lack further detail), but they are generally understandable in context.

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 tool's purpose as 'Assemble engineering context with output ordering' and hints at a processing pipeline, which conveys its primary function. However, it does not explicitly define what 'engineering context' covers (e.g., memories, decisions, bugs), relying partly on sibling tool names for 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 provides no guidance on when to use this tool instead of alternatives like memory_search_tool or memory_recent_tool. It does not mention use cases, suitability, or comparisons, leaving the agent to infer when this tool is the right choice.

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 mentions the impact field's allowed values (low/medium/high/critical), which is a small behavioral hint, but it doesn't describe side effects, permissions, reversibility, or the nature of the operation beyond being a wrapper. Significant gaps 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 concise, using a single sentence plus a list of allowed impact values. It front-loads the primary action and then notes the wrapper relationship. However, it could be better structured by separating the allowed values into a clearer format, but overall it's not 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?

Despite having an output schema (so return values are covered elsewhere), the description is grossly incomplete for a tool with 7 parameters. It fails to explain the purpose of most parameters, when to use this tool over alternatives, or any behavioral context. Given no annotations, the description is inadequate for an agent to call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It only addresses the 'impact' parameter with allowed values, adding value over the schema's plain string type. However, it provides no semantics for the other six parameters (title, question, tags, details, project, interpretations), leaving them undocumented.

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

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

The description states a clear verb ('Flag') and resource ('an ambiguity'), and mentions it is a convenience wrapper for ambiguity_create, which helps distinguish it from the sibling tool. However, it doesn't elaborate on what 'flagging' entails beyond creating an ambiguity record, so it's clear but not highly specific.

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

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

The description provides only minimal guidance: it says it's a convenience wrapper for ambiguity_create, implying it's a simpler alternative. But it doesn't specify when to use this vs other similar tools (e.g., open_question_create, assumption_create) or when not to use it. No explicit exclusions or context are given.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'create a gotcha memory' without mentioning side effects, return values, permissions, or whether the operation is reversible. This is insufficient 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 a single, concise sentence with no fluff, but it is too terse for the tool's complexity. It lacks structured detail (e.g., bullet points or examples) that would aid understanding 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 six parameters, no annotations, and no parameter descriptions, the description is grossly incomplete. It provides only a vague purpose and fails to explain the domain of 'gotcha', how it differs from other memory types, or what the expected output is. An agent cannot confidently call this tool correctly.

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

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

Schema description coverage is 0%, and the description mentions none of the six parameters (title, statement, tags, details, project, trigger). The agent is left to infer parameter meanings from names alone, with no additional context from the description.

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

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

The description clearly states the action (create) and resource (gotcha memory) and provides a defining attribute ('non-obvious behaviors'), which distinguishes it from siblings like bug_create or assumption_create. However, it doesn't elaborate on what a 'gotcha' specifically means in this context, 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?

There is no guidance on when to use gotcha_create versus its many siblings (e.g., bug_create, decision_create). The description implies usage for recording non-obvious behaviors but doesn't explicitly state conditions, alternatives, or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses one important behavioral trait: the tool does not auto-promote to invariant/decision, which is a meaningful constraint. However, it does not disclose other behaviors such as side effects, required permissions, or what happens on successful creation. The single behavioral note is useful but not comprehensive.

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 extremely concise: two sentences with zero wasted words. The primary purpose is front-loaded in the first sentence, and the critical behavioral constraint is stated in the second. Every word earns its place, achieving maximal clarity with minimal 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 10 parameters, 4 required, and zero schema descriptions, the description is grossly inadequate. It provides no guidance on parameter semantics, field relationships, or expected input format. Even though an output schema exists, the agent cannot correctly construct a call without understanding the parameters. The description is far too thin for a tool of this complexity.

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

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

Schema description coverage is 0%, meaning the input schema provides no descriptions for any of the 10 parameters. The description adds no parameter-specific information whatsoever—it does not explain what 'statement', 'hypothesis', 'confidence', or 'evidence_for' mean, nor which fields are required. With such a gap, the agent has no guidance on how to populate the parameters, making this dimension critically weak.

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 and resource: 'Create a hypothesis memory.' It also implies a distinction from invariant/decision tools via the 'Never auto-promote' clause, but it does not explicitly contrast with other memory creation siblings like assumption_create or observation_create, so it is not fully differentiated. Still, the purpose is 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 instruction 'Never auto-promote to invariant/decision' explicitly tells the agent when not to use this tool (for invariants/decisions) and implies it is for hypotheses that should remain tentative. It does not mention alternative tools for assumptions or observations, but it does provide a clear exclusion for two key siblings, which is helpful 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 provided, the description carries the full burden of disclosing behavioral traits. It only states that it creates a memory, but gives no information about side effects, required permissions, validation rules, or what happens on conflict. It is not misleading, but it is severely under-specified for a create operation.

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

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

The description is a single, front-loaded sentence that is not verbose. However, it is so sparse that it provides minimal value beyond the tool name. Conciseness is good, but the content does not earn its place because it omits essential 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?

Given the high parameter count (12) and required fields (6), plus the absence of annotations and low schema coverage, the description is woefully incomplete. It does not explain the purpose of any parameter, the meaning of 'implementation memory', or how the tool behaves. An agent would struggle to invoke it correctly without additional documentation.

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 offers almost no parameter guidance. The parenthetical list of fact types (API, function, etc.) hints at the domain but does not explain any of the 12 parameters, including the 6 required ones. The description fails to compensate for the lack of schema documentation.

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

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

The description states a specific verb ('create') and resource ('implementation memory'), and enumerates the covered fact categories (API, function, module, type, config, schema). This clearly differentiates from other 'create' tools by the 'implementation' qualifier, though it does not explicitly name sibling 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 no guidance on when to use this tool versus the many sibling memory-creation tools (e.g., gotcha_create, assumption_create). There is no mention of selection criteria, prerequisites, or context. The agent must infer from the name and the generic list of codebase 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 provided, the description must disclose behavior, but it only mentions two required fields without explaining side effects, permissions, or consequences. It does not describe what happens on success or failure, nor any irreversible 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 extremely short, but this is under-specification rather than conciseness. It contains only two sentences with no useful structure or front-loading of critical information.

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

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

The tool has 8 parameters, 5 required, no enums, and an output schema (not described). The description provides almost no contextual information needed for correct invocation, leaving the agent to guess parameter semantics and 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 description coverage is 0%, so the description must compensate by explaining parameters. It only names 'verificationMethod' and 'condition' (using inconsistent naming versus the schema's verification_method), omitting the other six parameters entirely and providing no meaning for any of them.

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 ('Create an invariant memory') which identifies the resource and the operation. However, it does not explain what an invariant memory is or how it differs from sibling tools like assumption_create or constraint_create, leaving the purpose somewhat generic.

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 the many sibling creation tools. The description gives no context, prerequisites, or exclusions, so an agent cannot decide between invariant_create and other memory creation 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?

There are no annotations, so the description carries the full burden. It explains key behavior: only tagged command memories are returned, limit controls result count, and project is auto-detected from git root when omitted. It does not discuss sort order or behavior when no git root exists, but the listed behavior is meaningful and non-misleading.

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

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

The description is front-loaded with the core purpose and then uses a compact Args block for parameters. Every sentence contributes useful information and there is 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?

For a simple listing tool with an output schema and no required parameters, the description covers the main invocation behaviors and parameter meanings. It could add one sentence about when to prefer this over memory_list_tool, but nothing essential for a basic call is missing.

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

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

The schema only provides types and defaults, so the description adds essential semantics: limit is the maximum items to return, and project is an optional path auto-detected from git root. Both parameters are clearly explained beyond the raw schema.

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

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

The description uses a specific verb and resource: 'List command outcome memories (gotchas tagged with cmd:*).' It clearly identifies the exact subset of memories this tool manages, which distinguishes it from generic siblings like memory_list_tool and memory_search_tool.

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

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

The description implies the right context by saying it lists command outcome memories, but it does not explicitly state when to use this tool versus alternatives or mention any exclusions. It gives clear context but no direct 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 carries the full burden and does disclose real behavioral detail: confidence derivation cascades by asserted_by with hypotheses capped at 0.4, invariant items require verificationMethod and condition, decision items strongly recommend rationale, supersedes_id marks the prior item superseded, applicability is orthogonal to status, and project is auto-detected from git root. These are meaningful conditional/derivation rules, though no auth, rate-limit or error behavior is mentioned.

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 one-line purpose is front-loaded, followed by a tight Args block where each line adds distinct semantics (enum values, defaults, conditional requirements). It is long only because the schema has 19 undocumented parameters; no sentence is 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 19-parameter mutation tool with zero schema descriptions and no annotations, the description supplies the semantics an agent needs for the important fields, and return values need not be described because an output schema exists. The four undocumented infrastructure params (actor, session, request_id, operation_id) are the only completeness gap.

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

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

Schema coverage is 0%, so the description must compensate, and it does for 15 of 19 params, including enum values for type/asserted_by/applicability, formats for scope and evidence objects, and defaults/derivations for confidence and importance. It leaves actor, session, request_id and operation_id entirely unexplained, which is the only real gap.

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

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

The description states a specific verb and resource ('Create a new memory item'), and the type enum signals it is the generic creator covering decision/invariant/gotcha/etc. However, it never explicitly distinguishes itself from the sibling typed creators (decision_create, invariant_create, gotcha_create), leaving the agent to infer which to call.

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

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

There is no when-to-use or when-not-to-use guidance. The list of valid types implies the typed siblings exist, but the description never says 'prefer decision_create for decisions' or when the generic tool is appropriate versus the specialized ones. Context is entirely absent.

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 burden. It usefully discloses that deletion is 'soft' (implying recoverability) and that reason is mandatory, which is real behavioral value. However, it omits permission requirements, recovery path, and what happens to relations of the deleted item.

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 key constraint ('Reason is required') is front-loaded right after the verb+resource, and the Args block is terse. Slightly verbose in restating id/reason descriptions, but overall efficient.

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

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

An output schema exists, so return values need not be explained. But for a 7-param mutation tool with no annotations, the description leaves half the parameters and the authorization/recovery model undocumented, so it is only partially 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%, so the description must compensate. It documents id, reason, and project semantics (auto-detection from git root), covering 3 of 7 parameters, but leaves actor, session, request_id, and operation_id entirely unexplained.

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

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

States a specific verb and resource: 'Soft-delete a memory item'. This is clear enough to distinguish from siblings like memory_get_tool or memory_create_tool. It does not explicitly name any alternative or contrast, 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?

It notes that a reason is required, which is a prerequisite, but offers no guidance on when to delete versus alternatives like memory_update_tool, memory_gc_tool, or resolve_conflict_tool. No when-to-use or when-not-to-use context is 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?

With no annotations provided, the description must carry the behavioral disclosure burden. It does convey the scope and the auto-detection behavior for the project path, but it does not explicitly state whether the operation is non-destructive, whether it returns JSON directly or writes a file, or what happens if git root detection fails. 'Export' implies a read operation, but more explicit transparency would be stronger.

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, front-loaded sentences: the purpose comes first, followed by the only parameter. Every sentence adds value and there is no redundant 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?

This is a simple tool with one optional parameter and an output schema present, so the description does not need to explain return values. It covers the exported content, the format, and project resolution behavior, making it complete for the tool's complexity.

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

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

Schema coverage is 0%, but the description fully compensates for the single parameter: it clarifies that 'project' is a root path, that it is optional, and that it is auto-detected from the git root when omitted. This is exactly the information an agent needs beyond the schema's bare type/default.

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

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

The description uses a specific verb ('Export'), names the exact resource ('all memories and conflicts'), and specifies the output format ('portable JSON'). This clearly distinguishes it from sibling tools like memory_list_tool, memory_get_tool, and memory_import_tool.

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 operation is clear enough that an agent can infer this is for full exports/backups, but the description does not explicitly state when to prefer this over alternatives or when not to use it. There is no mention of scenarios like partial exports or selective retrieval, which the sibling tools might handle.

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 load and does well: it names exactly which items are destroyed, discloses the relation-reference guard, and front-loads the dry-run default as a safety mechanism. Gaps remain around irreversibility and the undocumented actor parameter, which hints at an audit/attribution behavior that is never 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?

Front-loaded and well organized: purpose, eligibility, safety default, then an Args block. The Args entries restate schema defaults, which is mild redundancy, but with zero schema descriptions the block still adds value rather than padding.

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

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

An output schema exists so return values need not be described. For a destructive operation with no annotations and 0% schema coverage, the description is adequate on eligibility and dry-run but silent on actor semantics, permissions, and reversibility, leaving the agent short of what it needs to invoke this confidently.

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

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

Schema description coverage is 0%, so the description must compensate, and it documents 3 of 4 parameters with meaning beyond the schema defaults (age threshold, report-only mode, git-root auto-detection). The actor parameter is left entirely unexplained in both schema and description, leaving a real gap.

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

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

States a specific verb (purge) and resource (terminal-state memories) plus the exact eligibility predicate: superseded/invalidated/resolved items untouched for retention_days and not referenced by any relation. That precision effectively separates it from memory_delete_tool, but no sibling is named explicitly, so it stops short of a 5.

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

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

The description conveys implicit usage context via 'Defaults to dry-run' and the eligibility rules, which tells the agent this is a cautious, criteria-driven cleanup rather than arbitrary deletion. However it never states when to prefer this over memory_delete_tool or memory_update_tool, nor any when-not condition.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It discloses the staleness-checking behavior and project-root auto-detection, which is useful, but it does not explain failure behavior for missing IDs, what 'staleness check' entails, or the return shape. The description is reasonably transparent but has 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?

The description is concise and front-loaded: one clear summary sentence followed by a tight parameter list. Every line adds information, with no filler, redundancy, or unnecessary background.

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 single-item retrieval tool with three parameters and an output schema, the description covers purpose, parameter semantics, and key behavior. It could be slightly more complete with explicit guidance on when to prefer search/list tools, but overall it gives an agent enough to select and 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?

Despite 0% schema description coverage, the description fully documents all three parameters: id identifies the memory item, include_evidence controls evidence staleness checking with its default, and project explains optionality and git-root auto-detection. This adds substantial meaning beyond the bare input schema.

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

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

The description opens with 'Retrieve a memory item by ID with staleness check,' which states a specific action, resource, and lookup key. This clearly distinguishes it from sibling tools like memory_search_tool, memory_list_tool, and memory_recent_tool.

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 makes the usage context clear: use this tool when you have a specific memory item ID and need to retrieve it, optionally checking evidence staleness. It does not explicitly name alternatives or state when not to use other tools, so it stops short of full 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 carries the full burden. 'Immutable timeline' implies a read-only historical view, which is one useful behavioral hint, but it says nothing about permissions, whether pagination applies, or how the timeline is scoped. Largely insufficient for a tool with zero annotation coverage.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though its brevity contributes to gaps elsewhere rather than being a model of completeness.

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

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

An output schema exists so return values need not be explained, but for a two-parameter read tool with no annotations and 0% parameter coverage, the description is too thin. It omits parameter meaning, usage routing, and behavioral scope, leaving the agent under-equipped.

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

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

Schema coverage is 0% across two parameters (id required, project nullable). The description references identifying 'a memory' only obliquely and says nothing about what 'project' does or how id and project interact, so it fails to compensate for the undocumented schema.

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

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

The description states a specific verb ('Show') and resource ('timeline of a memory') and enumerates the timeline contents (created, updated fields, deleted), making the operation distinguishable from a plain 'get'. It does not name or contrast with siblings like memory_get_tool or memory_recent_tool, so it earns a 4 rather than 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 versus memory_get_tool (current state) or memory_recent_tool. No prerequisites, conditions, or exclusions are given, leaving the agent to infer the use case from the name alone.

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

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

No annotations are present, so the description must carry behavioral disclosure. It usefully reveals that duplicate IDs are skipped and that project root is auto-detected from git, but it does not explain side effects, conflict handling, or reversibility of the import.

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

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

The description is concise and front-loaded: one behavioral sentence followed by a terse Args block. Every sentence adds information, with no fluff or repetition.

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

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

For a two-parameter import tool with an output schema, the description covers the inputs and key duplicate behavior. The main gap is the meaning/role of the optional 'conflicts' key, but passing the export dict as-is is still clear.

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 this description compensates by explaining both parameters: data is an export dict with 'items' and optional 'conflicts', and project is optional with git-root auto-detection. It doesn't define the inner shape of 'items' or 'conflicts', but adds meaning far beyond the bare schema.

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

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

The description states the action 'Import' and the resource 'memories', and specifies the input is a previously exported dict, which clearly distinguishes it from memory_create_tool and memory_export_tool. The duplicate-ID behavior further clarifies what the tool does.

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 clearly implies the use case of restoring/importing memories from an export dict and notes project auto-detection behavior. It does not explicitly name alternatives or state when not to use it, so it stops short of a perfect 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?

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It does add useful behavior details like sort defaults, limit default, tag matching semantics ('items must have at least one'), and project auto-detection from git root. However, it does not explicitly state that the operation is read-only, how filters combine, or sorting direction, leaving some behavioral traits 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 compact and front-loaded with the core purpose, followed by a clear parameter list. Every line adds necessary information, and there is no repetition of schema-only details or filler content.

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 an output schema present and all six parameters documented, the description is mostly complete for invocation. However, it lacks guidance on pagination/offset behavior, filter combination semantics, and how listing differs from sibling tools like memory_search_tool or memory_recent_tool, making it slightly less complete given the tool ecosystem.

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 fully compensates by explaining every parameter: valid values for type, status, and sort, default limit, tag filter semantics, and project auto-detection. This goes well beyond the bare schema and gives an agent everything needed to construct valid arguments.

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

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

The description clearly states the tool lists memory items with optional filters, naming the specific resource (memory items) and action (list). However, it does not distinguish itself from siblings like memory_recent_tool or memory_search_tool, so it lacks explicit 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 this tool versus alternatives such as memory_search_tool, memory_recent_tool, or memory_get_tool. The filter parameters imply general listing use cases, but the description never states exclusions or preferred conditions.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It discloses ordering by recency, limit semantics, and automatic git-root detection. The verb 'List' also implies a non-mutating read operation, and return structure is covered by the output schema.

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

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

The description is short, front-loaded with the core purpose, and uses a concise Args block. Every sentence provides useful information with no filler.

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

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

For a simple read-only listing tool with an output schema, the description covers what the tool does, parameter behavior, and project resolution. No critical invocation detail is missing 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?

Despite 0% schema description coverage, the description fully explains both parameters: limit has a maximum and a default of 5, and project is optional with auto-detection from the git root. This completely compensates for the schema gap.

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

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

The description states a clear verb and resource: 'List most recently created memories.' It is specific about the recency scope, but it does not explicitly differentiate the tool from siblings such as memory_list_tool or memory_search_tool.

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

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

There is no guidance about when to use this tool instead of the sibling memory tools. The project auto-detection note is useful for invoking the tool but does not help an agent decide between alternatives.

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

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

With no annotations, the description carries the full burden. It does disclose a meaningful side effect — 'supersedes/invalidates update the target status' — which is real behavioral value. However, it omits duplicate-relation handling, whether missing IDs error out, and directionality semantics beyond from/to.

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 purpose is front-loaded in one line, followed by a compact Args block; the enum list is dense but each entry is informative. No filler sentences.

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

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

An output schema exists, so return values need no explanation, and the arg docs cover the required inputs. For an unannotated mutation tool, though, more disclosure about failure modes and duplicate relations would be needed for a higher score.

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

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

Schema description coverage is 0%, so the description must compensate, and it does for the three required params: it defines from_id and to_id as source/target memory IDs and, critically, enumerates the allowed relation kinds plus what two of them do to the target. It leaves actor, session, request_id, and operation_id entirely unexplained, which is the main gap.

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

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

The first line states a specific verb and resource: 'Create a typed relation between two memories.' It is distinguishable from siblings like memory_relations_tool (listing relations) and resolve_conflict_tool, though it doesn't name any alternative explicitly.

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

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

There is no when-to-use guidance: nothing says when to link memories via this tool versus resolving a conflict, updating a memory, or listing relations. Usage is only implied by the verb 'Create'.

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. 'List' weakly implies a read-only operation, but the description says nothing about relation direction (incoming vs outgoing), whether the project scope changes results, result volume/pagination, or permissions required.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficiently structured, though its brevity is achieved partly by omitting necessary detail rather than by tight editing.

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

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

An output schema exists, so return shape need not be described. However, for a two-parameter tool with 0% schema coverage, no annotations, and no usage routing, the description leaves the agent without enough context to call it correctly in ambiguous cases.

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 there are two parameters. The description's phrase 'involving a memory' loosely hints at the required 'id', but the optional 'project' parameter is never mentioned in the schema or the description, so an agent has no basis for using it.

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 specific resource ('typed relations'), and a scope ('involving a memory'), so an agent knows exactly what it returns. It stops short of naming or contrasting with the sibling memory_relate_tool, which would have made the purpose differentiation explicit.

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 versus alternatives such as memory_relate_tool (which presumably creates relations) or memory_get_tool (which likely returns the memory itself). Usage is only implied by the word 'List', with no exclusions or conditions 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 full behavioral burden. It usefully discloses that dry_run defaults to True (safe-by-default) and that 'void' is a state-changing operation, but it does not say whether voiding is reversible, whether records are deleted or flagged invalid, permission requirements, or blast radius.

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 front-loaded sentence stating the effect, followed by a compact Args block with no filler. The dry_run note is slightly redundant with the schema default but reinforces the safe mode.

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

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

An output schema exists, so return-value detail is not required. However, for a mutation tool with zero annotations and an undocumented 'actor' parameter, the description leaves out what 'voiding' actually does to the verification records and any audit/authorization implications.

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 all 3 parameters are undocumented in the schema, so the description must compensate. It explains dry_run's default and project's git-root auto-detection well, but the 'actor' parameter is never mentioned anywhere, leaving one third of the parameters with zero semantics.

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

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

States a specific verb ('Void') and a precisely scoped resource ('verifications whose evidence changed since they were made'), which is distinctive from sibling memory_verify_tool and memory_gc_tool. It does not explicitly name a sibling to differentiate against, but the operation itself is 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?

No guidance on when to run this versus memory_verify_tool or memory_gc_tool, and no stated prerequisites (e.g., that verifications must exist first). The only usage-shaped hint is the dry_run default of True, which implies a safe inspection-first workflow but is not framed as 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 provided, the description carries the behavioral burden and does reasonably well: it discloses FTS5-based full-text search, filtering by types/tags, the include_stale option, and project auto-detection from git root. It does not explain ranking behavior or what 'stale' means precisely, but the main behavioral traits are present.

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

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

The description is compact and front-loaded with a clear one-line summary followed by a parameter list. Each line has a purpose, with no fluff, though the word 'full-text' appears twice and the 'Args:' label is slightly mechanical.

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 output schema exists and the tool has moderate complexity, the description covers all invocation-relevant aspects: query, filters, limits, stale handling, and project scoping. It could be more complete about accepted type/tag values and hybrid ranking semantics, but it is sufficient for basic correct 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 description coverage is 0%, so the description must compensate, and it does: all six parameters get one-line explanations. The query parameter gains FTS5 context and project gains auto-detection detail, though 'types' and 'tags' remain somewhat generic without enumerating valid values.

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 ('search') with a resource ('memory') and a distinguishing mechanism: 'Hybrid tag + full-text search'. It is clear enough to differentiate from memory_get, memory_list, and memory_recent, though it does not explicitly mention those siblings.

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

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

Usage is implied by the word 'search' and the filter parameters, but there is no explicit guidance on when to prefer this tool over memory_list_tool or memory_recent_tool. No exclusions or alternative tool names 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?

Despite lacking annotations, the verb 'List' clearly indicates a read-only operation with no destructive side effects. The description does not mention authentication or other behavioral details, but the operation type is transparent enough for a safe read.

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 extremely concise and well-structured, with a one-sentence summary followed by a clear parameter list. No unnecessary words or repetition.

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 operation with two self-explanatory parameters, the description is complete. The absence of an output schema is acceptable because the purpose is clear and the expected return (a list of memories) is inferable.

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 explicitly explains both parameters: 'limit' is defined as the maximum number of items to return with a default, and 'project' is described as an optional project root path with auto-detection behavior. This exceeds the minimal schema 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 action (List), the resource (task memories), and the specific filter (tagged with task:*), making its purpose unambiguous and distinct from sibling tools like memory_list_tool or memory_recent_tool.

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 relationships to sibling tools such as memory_search_tool or memory_recent_tool, leaving the agent to infer the appropriate 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 behavioral burden. It usefully discloses that reason defaults to 'maintenance', enumerates valid status values, and notes project auto-detection from git root. However, it never states whether the update is a partial merge or full replace, whether it is reversible, or permission requirements – critical omissions 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?

Front-loaded with the core purpose followed by a clean, scannable args list. Mostly efficient, though a few entries ('New tags', 'New evidence list') are pure restatement of the parameter name.

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

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

An output schema exists so return values need not be explained. But for a 16-parameter mutation tool with no annotations, the missing update semantics (partial vs full replacement) and four undocumented parameters leave meaningful 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 coverage is 0%, so the description must compensate and largely does, annotating 12 of 16 parameters with meaning beyond their bare names and giving the status domain. It leaves actor, session, request_id, and operation_id entirely undocumented, and several entries (tags, metadata) are only restated.

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+resource ('Update a memory item') and the args list makes clear which entity and fields are touched. It is distinguishable from create/delete/revalidate siblings, though it never explicitly names them to sharpen the boundary.

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?

Usage is implied by the field list and the note that 'reason' is strongly recommended for an audit trail, but there is no explicit when-to-use or when-not-to-use guidance relative to memory_revalidate_tool or memory_relate_tool. The agent must infer that this is the general-purpose field editor.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose the mutation effects (sets verified_at and verified_commit) plus several defaults (commit defaults to HEAD, confidence defaults to 1.0, project auto-detected from git root). It omits whether verification is idempotent, what happens if the item is already verified, permission/auth needs, and how it differs from revalidation — meaningful gaps for a state-mutating 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 key fact — what state is written — is front-loaded in the first sentence, followed by a short rationale and a clean arg list. The prose is tight; the only mild bloat is that the args list repeats default values that also appear in the schema.

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

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

An output schema exists, so return values need not be described, and the side effects and defaults are covered. Still, for an unannotated mutation tool with four undocumented parameters, the description stops short of the idempotency, failure-mode, and sibling-routing information an agent would need to invoke it confidently.

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

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

Schema description coverage is 0% across 10 parameters, so the description must compensate, and it explains 6 of them with real semantics (method stored in history, commit defaults to HEAD, verified_by_id is a memory ID holding the verification artifact, project auto-detected). The remaining four (actor, session, request_id, operation_id) are undocumented in both the schema and the description, so compensation is only partial.

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+resource: recording that a memory item was verified, and names the exact state it writes (verified_at, verified_commit). That is far more concrete than the name alone. It does not, however, differentiate itself from the close sibling memory_revalidate_tool, leaving the agent to guess which one applies.

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?

"Verification, not provenance, is what earns confidence 1.0" implies why and when to use this tool, and the confidence default of 1.0 reinforces that intent. But there is no explicit when-not-to-use and no routing between this and memory_revalidate_tool or memory_update_tool, so the agent must infer the selection rule.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal one important trait: it will never auto-promote to invariant/decision. However, it omits other potentially relevant behaviors such as whether the operation is reversible, any permission requirements, or side effects beyond creation. For a create operation, the mutation is implicit, but additional context about what happens on success or failure 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 extremely concise, using just two sentences with no filler. It front-loads the core purpose and includes the important behavioral caveat. However, it is so brief that it sacrifices necessary detail, so while it is efficient, it is under-specified. The structure is clear and scannable.

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 (8 parameters, 4 required), 0% schema coverage, and no annotations, the description is severely incomplete. It fails to explain what an observation memory is, how the parameters relate, or any constraints. The output schema exists but doesn't compensate for the lack of input guidance. An agent would struggle to call this tool correctly without external knowledge.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameter meanings, but it provides none. The 8 parameters (especially 'statement' vs 'observation', 'context', 'details', 'project', 'confidence') are entirely undocumented. An agent receives no help in distinguishing these fields or understanding required formats. This is a critical gap.

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

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

The description states a specific verb ('Create') and resource ('observation memory'), which clearly defines the tool's primary function. It distinguishes from sibling tools by naming the memory type, though it doesn't explicitly contrast with alternatives. The 'Never auto-promote' clause adds a nuance but doesn't detract from clarity.

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

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

There is no explicit guidance on when to use this tool versus the many sibling creation tools (e.g., assumption_create, decision_create). The description implies its use for observation memories, but provides no criteria for selection, no exclusions, and no context about when an observation is appropriate vs. other types. The 'Never auto-promote' is a behavioral rule, not usage 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 full burden of explaining side effects, permissions, or error conditions. It only mentions an 'impact' field with allowed values, but does not clarify the tool's behavior, such as whether it writes to a persistent store or triggers notifications.

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 extremely concise, using a single sentence with no redundant words. It is well-structured, but the brevity sacrifices necessary detail; still, as a pure measure of conciseness, it is effective.

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

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

Given the tool's complexity (9 parameters, 6 required) and the lack of schema descriptions, the description is far too sparse. It does not explain the purpose of an open question, how to fill the parameters, or what the output might look like, leaving many aspects ambiguous.

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 9 parameters. Terms like 'statement', 'blocking', and 'possible_answers' are left undefined, and the note about 'impact' is ambiguous without a parameter reference.

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 ('Create') and the object ('open question memory'), which distinguishes it from other memory creation tools. However, it does not elaborate on what an 'open question' specifically entails beyond the name.

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 gotcha_create or assumption_create. The description does not mention scenarios or conditions that would make an open question the appropriate choice.

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 discloses meaningful behavior: it auto-hashes content and performs an upsert ('updates existing or creates new'), and explains the downstream benefit (prevents re-reading). It omits permission/auth requirements and whether writes are reversible, but the upsert and hashing semantics are genuinely useful disclosure.

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

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

Front-loaded with purpose and trigger in the opening sentences, followed by a compact per-argument block. Zero filler, though the Args list is long by necessity and slightly restates the schema property names.

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 11 parameters, 5 required, 0% schema coverage, and an existing output schema, the description supplies the missing parameter meaning and the mutation/upsert semantics an agent needs to call it correctly. Only auth/permission context is missing, which is minor here.

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

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

Schema coverage is 0%, so the description must compensate, and it does: all 11 parameters are documented with concrete examples ('src/auth.py', 'getUser() returns User | null', symbol 'UserService.authenticate'), it supplies enum-like values for 'kind' (api/function/module/type/config/schema) absent from the schema, and notes auto-detection/defaults for start_line, end_line, project, and title.

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

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

States a specific verb and resource ('Register facts learned from reading a file') and immediately contrasts it with the write counterpart by scoping to file reads and stating it 'Prevents re-reading the same file in future sessions.' An agent can distinguish it from register_file_write_tool without opening the schema.

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?

Explicit when-to-use: 'Call this after reading a file to store what you learned.' Gives the trigger condition clearly, but offers no exclusions or explicit routing rules against the many sibling memory tools (memory_create_tool, observation_create, etc.).

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 well: it discloses auto-hashing, the upsert semantics (updates existing or creates new), and the blocking commit-gate behavior, which is a major operational trait. It stops short of describing failure modes, permissions, or idempotency guarantees.

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

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

Front-loads the purpose sentence, then usage context, then the args block. The args section is long but earns its place given zero schema description coverage. Structure is scannable and no sentence is wasted.

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

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

For a 10-parameter mutation tool with an output schema present, the description covers the two things the schema cannot: the blocking commit-gate behavior and the full semantics of every parameter. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 0%, so the description must compensate and it does fully, documenting all 10 parameters with inline examples ('src/auth.py', 'Added input validation to getUser()', 'Fix: getUser() crashed on null input'). Each optional param (start_line/end_line, title, details, symbol, project) is explained, including project's auto-detection from git root.

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 (Register) and resource (file write/modification) with the key behavioral qualifier 'Auto-hashes content, updates existing or creates new.' This clearly distinguishes it from the sibling register_file_read_tool without ambiguity about which operation is being registered.

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?

Explicitly says 'Call this after editing or writing a file to document what changed and why' and reveals the enforcement mechanism: the commit-gate hook blocks all other tools until the write is registered. This tells the agent exactly when the tool is mandatory, which is stronger than a typical when-to-use hint.

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, and the description only mentions creating a memory. It does not disclose side effects (e.g., whether it overwrites existing memories, tags required, or how it integrates with other memory functions). Without this information, agents cannot anticipate the tool's full impact.

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 extremely concise (two sentences) with no unnecessary words. It packs the core action and purpose into a minimal, well-structured form, making it easy to parse quickly.

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 (8 parameters) and the lack of parameter explanations, the description is insufficient for an agent to fully understand how to use the tool correctly. It omits crucial context about parameter relationships, required vs. optional fields, 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?

The schema has zero descriptions for any of the 8 parameters. The description text does not explain the meaning of fields like 'proposal', 'reason_rejected', 'replacement', or 'project'. Agents are left to guess parameter semantics, which is critical for proper invocation.

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 (Create), the specific resource (a rejected idea memory), and the purpose (Prevents re-proposing dead ends). This distinguishes it from other memory tools in the sibling set that target different content types (e.g., gotcha, assumption).

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 'Prevents re-proposing dead ends' gives a strong contextual clue for when to use this tool (when an idea has been rejected). However, it does not explicitly contrast with alternative tools like the generic memory_create_tool, leaving some inference required. Still, the purpose is clear enough to guide 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 the full burden. It is a mutation ('mark as resolved') but does not disclose side effects, permissions, reversibility, or what happens to the conflict afterward. It does add one useful behavioral note — project auto-detection from git root — which lifts it above a bare minimum.

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 one-line summary is front-loaded and the Args block is compact with no filler. Structure is clean and appropriate for the content given.

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

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

An output schema exists, so return values need not be described. But a mutation tool with zero annotations and four undocumented parameters, plus no usage or lifecycle context, leaves the agent without enough to invoke it confidently.

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

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

Schema description coverage is 0% and there are 7 parameters, yet the description documents only conflict_id, resolution (with an example), and project. The remaining four (actor, session, request_id, operation_id) are left entirely undefined, so the description only partially compensates for the coverage gap.

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

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

The description states a specific verb and resource: 'Mark a conflict as resolved.' An agent can tell what the tool does. However, it offers no differentiation from sibling tools (e.g., ambiguity/flag tools), 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, no prerequisites (e.g., the conflict must exist / be open), and no when-not conditions. The text is purely a parameter 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?

With no annotations provided, the description carries the behavioral burden. It discloses that the tool creates a directory and DB, and the phrase 'if missing' implies non-destructive behavior. However, it does not describe permissions, idempotency guarantees, or consequences of re-running in an already-initialized project.

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 appropriately concise: two short sentences plus a compact args block. The main action is front-loaded, and every sentence adds useful information without padding.

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

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

For a simple one-parameter init tool with an output schema present, the description covers the essential behavior and parameter semantics. It could be slightly more complete by explicitly stating git-root dependence, but overall an agent has enough to invoke it correctly.

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

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

Schema coverage is 0%, but the description compensates well for the single parameter: it states 'project' is optional, describes it as a project root path, and adds the valuable detail that it is auto-detected from git root when omitted.

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: 'Initialize totem for a project' and specifies what it creates ('.totem/ directory and DB'). This clearly distinguishes it from the sibling memory tools, though it does not explicitly name alternatives.

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 first-time setup by saying 'Initialize totem for a project' and explains the optional project argument, but it does not explicitly state when to use this tool versus not using it, nor mention prerequisites like being inside a git repository when project is omitted.

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