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 indicates a read-only retrieval operation ('Get all...') but does not elaborate on potential side effects, authentication needs, or data volume. A score of 3 is appropriate as it adds basic context but is not rich in behavioral details.

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

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

The description is a single sentence with 5 words, front-loading the purpose. Every word is meaningful: 'Get' signals retrieval, 'all' indicates scope, 'technical/architecture decisions with reasoning' defines the content. No wasted text.

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

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

Given the tool has 0 parameters, no required arguments, and an output schema exists, the description is mostly complete. It explains the purpose clearly. It could be slightly enhanced by hinting at the output format or typical usage context, but it adequately serves its purpose for a parameterless tool.

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

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

The input schema has 0 parameters and schema description coverage is 100%, so the schema is complete by default. Since there are no parameters, the description does not need to add param-level guidance, and the baseline for no parameters is 4. The description adds value by clarifying the specific type of data returned (decisions with reasoning).

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

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

The description uses specific verbs ('Get') and a clear resource ('technical/architecture decisions'). It distinguishes itself from siblings by narrowing the scope to decisions with reasoning, which is a distinct subset of contextual data not covered by tools like ctx_search or ctx_get.

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 when to use this tool (when you need technical/architecture decisions with reasoning) but does not provide explicit guidance on when not to use it or how it compares to alternatives like ctx_get or ctx_search. No exclusions or alternatives are mentioned.

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

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

With no annotations, the description carries full burden. It only says 'delete', implying irreversible removal, but does not disclose error handling, idempotency, required permissions, or return behavior. No additional behavioral traits are revealed.

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

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

The description is a single sentence, but it is under-specified rather than appropriately concise. It lacks critical details about usage and behavior, so brevity comes at the cost 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?

For a deletion tool with one required parameter, multiple sibling tools, and an output schema, the description is woefully incomplete. It omits success conditions, error handling, idempotency, and parameter guidance, leaving the agent to guess.

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 tool description does not mention the 'memory_id' parameter or its format/meaning. The agent receives no help beyond the schema's type declaration.

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 'Delete a memory from persistent context' with a clear verb and resource. It is unambiguous but does not differentiate from sibling tools like ctx_update or ctx_save, which could also involve memory manipulation.

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 such as ctx_update (modify) or ctx_save (create). The description lacks context for selection.

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

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

No annotations exist, so the description carries full burden. It states that the tool runs diagnostics and specifies output areas, which provides some transparency but omits side effects, required permissions, or whether it modifies state. The description is adequate but not rich.

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

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

The description is a single sentence with no filler. It is front-loaded with the core action and lists specific diagnostic areas. Every phrase is necessary.

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

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

Given that the tool has no parameters and an output schema exists, the description provides enough context for an agent to decide when to use it. It could mention whether the output schema includes all listed diagnostic areas, but this is minor.

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

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

The tool has zero parameters, so the description does not need to add parameter details beyond the schema. The description explains what the tool does when invoked without arguments, which adds value. Base score 4 for 0-parameter tools.

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

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

The description uses a specific verb 'Run environment diagnostics' and specifies the resource being diagnosed. It lists three diagnostic areas (missing env vars, config issues, health checks), clarifying the scope.

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 use when an agent needs to check the environment's health, but does not explicitly state when to use this tool versus alternatives like ctx_environment or when not to use it. No exclusions or contextual triggers 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?

With no annotations provided, the description carries the full burden. The verb 'Get' indicates a read-only operation, and the content list clarifies scope, but it does not disclose potential side effects, permission requirements, or performance characteristics such as Docker inspection time or .env file parsing.

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 packs the core purpose and key content areas without any fluff. Every word earns its place.

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

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

For a simple one-parameter tool, the description covers the main purpose and content, and the output schema exists to detail return values. However, it omits parameter semantics and usage boundaries, making it not fully complete for an agent to confidently invoke it in all situations.

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 0% description coverage for its sole parameter `detailed`, and the description does not explain the parameter's effect or how it alters the output. The name is somewhat self-explanatory, but the description fails to compensate for the missing schema documentation, leaving the agent to guess.

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 the specific verb 'Get' and identifies the resource as 'environment intelligence', listing concrete aspects (Python version, venv, dependencies, Docker, .env status). This clearly distinguishes from sibling tools like ctx_git or ctx_project which focus on other domains.

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 tool is to be used for environment inspection, but provides no explicit when-to-use guidance, exclusions, or alternative tool references. An agent must infer when to call this over ctx_project or ctx_diagnostics.

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

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

No annotations exist, so the description bears the full burden. It indicates a read-only retrieval ('Get'), which is clear. However, it does not disclose rate limits, size limits on returned data, whether the memory is returned in full or trimmed, or if authentication is needed. For a retrieval tool, 3 is fair given the 'full provenance' hint suggests rich data returns.

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, functional sentence with no wasted words. Every term ('specific memory', 'ID', 'full provenance') directly communicates the tool's purpose and distinguishes it from siblings.

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 a required single parameter, no enums, and an output schema present (which presumably describes return structure), the description is largely complete. It lacks guidance on obtaining the memory_id or handling missing IDs, but the tool's simplicity and the output schema reduce the need for more description.

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% (the input schema has no description for memory_id), so the description must compensate. It names 'memory_id' as the parameter but does not explain its format (e.g., UUID, string pattern) or how to obtain it. Baseline 3 since description adds minimal semantic value beyond the parameter name.

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

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

The verb 'Get a specific memory' clearly indicates retrieval by ID. It is well differentiated from siblings like ctx_search (search vs. exact ID lookup), ctx_save (creation), ctx_update (modification), and ctx_delete (deletion).

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. For example, it does not contrast with ctx_search for retrieving memories without knowing the exact ID, nor specify prerequisites like having a valid memory_id. The context of 'full provenance' is hinted but not elaborated.

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

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

No annotations are provided, so the description must disclose behavior fully. 'Get' implies read-only, which is positive, but it does not state side effects (none expected), authentication needs, or performance implications. The description adds a bit beyond structured fields by listing outputs and the 'detail' parameter values.

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 (three lines) and front-loaded with purpose. The parameter values list is useful but could be integrated more cleanly. Every sentence earns its place.

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

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

With one optional parameter and an output schema, the description is adequate but minimal. It does not explain default behavior (what 'summary' includes), or handle edge cases (no git repo). Given complexity is low, a 3 is appropriate.

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

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

There is only one parameter ('detail') with 0% schema description coverage. The description explicitly lists possible detail values ('summary, commits, files, todos'), which adds meaning beyond the bare schema. This compensates well 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 clearly states the verb 'Get' and resource 'Git intelligence', listing specific outputs (recent commits, changed files, branches, TODOs/FIXMEs). However, it does not explicitly distinguish from sibling tools like ctx_project or ctx_summary, which could also return project or summary info.

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

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

No guidance is given on when to use this tool versus alternatives like ctx_search or ctx_recent. The description does not mention context, prerequisites (e.g., git repository must exist), or when not to use it.

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

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

No annotations are provided, so the description carries the full burden. It explains the tool returns project metadata but does not disclose behavioral traits such as whether it reads from a local file or remote source, whether it requires authentication, or what happens if the project is not initialized. The output schema exists, but the description could add more context about side effects or state.

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

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

The description is a single, front-loaded sentence that lists key information. Every word contributes meaning, and there is zero verbosity.

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

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

Given the tool's simplicity (zero parameters, no annotations needed) and the existence of an output schema, the description is reasonably complete. It explains the return fields and purpose. However, it could mention if it requires the project to exist or what the fallback behavior is, but for a getter tool with zero complexity, this is sufficient.

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

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

The tool has zero parameters and schema coverage is 100%, so the description's job is minimal. It adds value by listing the exact fields returned (name, language, framework, root, git status), which helps an agent understand the output without inspecting the output 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 explicitly states the verb 'Get' and the resource 'current project information', and lists the specific fields returned (name, language, framework, root, git status). This clearly distinguishes it from sibling tools like ctx_search (searching) or ctx_git (git-specific operations).

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 implicitly conveys when to use this tool: to retrieve current project context. It provides no explicit when-not-to-use or alternative suggestions among the many sibling tools, but the purpose is clear enough that an agent would know to use it for project metadata, not for searching or other operations.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It lacks any mention of safety (e.g., read-only or destructive), performance considerations, or whether results are ordered (e.g., by recency). The agent cannot infer if this is a safe read operation.

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

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

The description is a single sentence, no filler words. It front-loads the action ('Get recent memories and latest session summary'). However, the sentence could be more compact by removing 'for continuity between sessions' if not necessary for clarity, but it's still appropriate 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 complexity (1 parameter, 12 sibling tools), the description lacks explanation of the 'limit' parameter, return value (even though an output schema exists), and ordering semantics. The tool's purpose is fairly simple, so a score of 2 reflects minimal completeness gaps: missing param semantics and behavioral transparency.

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

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

Schema description coverage is 0%, meaning the schema provides no descriptions for the single parameter 'limit'. The description does not explain this parameter beyond its default value of 10. No information is given about what 'limit' controls (e.g., number of memories, number of summaries, or something else).

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 retrieves 'recent memories and latest session summary' for maintaining continuity between sessions. While it uses a specific verb ('Get') and resource ('recent memories... session summary'), it doesn't explicitly differentiate from sibling tools like ctx_search or ctx_get, but the 'recent' and 'latest' qualifiers imply distinct scope.

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

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

The description implies this tool is for continuity between sessions, but it provides no explicit guidance on when to use it versus asking for specific memories via ctx_get or searching via ctx_search. No alternatives or exclusions are mentioned.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It states the tool returns 'all project rules and coding conventions,' which implies a read-only operation. However, it does not disclose whether the result is exhaustive, whether it requires authentication, or if there are pagination or performance implications for fetching 'all' rules. The description is adequate but leaves gaps for a no-annotation scenario.

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

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

The description is a single, concise sentence that is front-loaded with the core action. Every word is functional—'Get all project rules and coding conventions' is efficient and clear with no wasted text.

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

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

Given the tool has zero parameters, no annotations, and an output schema (which presumably describes the return structure), the description is fairly complete. It explains what the tool retrieves (rules and conventions) and implies it is a comprehensive read operation. Some minor context about scope (e.g., 'for the current project') could be added, but it is sufficient for an agent to understand the tool's purpose.

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

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

The input schema has zero parameters, so the description does not need to add parameter-level meaning. Baseline for 0 parameters is 4. The description covers the tool's purpose without needing to elaborate on any parameters.

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

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

The description clearly states 'Get all project rules and coding conventions,' which specifies the verb 'Get' and the resource 'project rules and coding conventions.' This distinguishes it from siblings like ctx_search (which likely searches for specific items) and ctx_save (which saves/persists data). However, it could be more precise about the scope (e.g., 'all rules for the current project').

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. For example, when should a user call ctx_rules instead of ctx_search or ctx_get? There are no explicit 'when to use' or 'when not to use' instructions, and no mention of alternatives among the 13 sibling 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 behavioral disclosure burden. It adds value by noting that context is "persistent" and lasts "across AI coding sessions," implying a long-term write operation. However, it does not mention whether saves overwrite existing entries, require special permissions, or produce specific side effects.

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

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

The description is brief and front-loaded, with the core action in the first sentence. However, there is some redundancy: 'memory, decision, rule, or fact' overlaps with 'technical decisions, project rules, coding conventions', and 'persistent context' is repeated as 'persist across AI coding sessions'.

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, no schema descriptions, and no annotations, making it relatively complex. The description covers purpose and usage but leaves parameter semantics entirely unaddressed. An output schema exists, so return values are likely specified there, but the agent still lacks critical information about how to properly configure saves.

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 0% description coverage for its 8 parameters, and the description does not compensate. It mentions 'content' implicitly by listing types of content to save, but gives no guidance on how to use 'type', 'scope', 'tags', 'confidence', 'importance', 'source', or 'source_type'. The agent is left to infer parameter semantics from names and defaults 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 explicitly states "Save a memory, decision, rule, or fact to persistent context," providing a specific verb (save) and resource (persistent context). It lists example content types, which clearly distinguishes this from read/search siblings like ctx_search and ctx_get.

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 second sentence gives clear usage context: "Use this to store technical decisions, project rules, coding conventions, or any important context that should persist across AI coding sessions." This tells the agent when to use the tool, though it does not explicitly name alternatives or when-not-to-use 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?

No annotations are provided, so the description must disclose behavior. It mentions that the tool 'Returns relevant memories within the specified token budget,' which reveals a key behavioral trait (token budget control) that is not obvious from the schema alone. As a search tool, it implies read-only access, but this is not explicitly stated. Still, the description adds meaningful context beyond the raw 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 three concise sentences, each serving a distinct purpose: stating what the tool does, when to use it, and what it returns. There is no fluff, and the critical information is front-loaded in the first sentence. Every sentence earns its place.

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

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

Given the tool has 5 parameters (with 0% schema coverage), no annotations, and an output schema (which may document returns), the description is incomplete. It omits explanations for most parameters and doesn't cover how to construct a query or use scoping. The agent would struggle to use the tool effectively 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?

The description only indirectly explains one parameter (token_budget via 'specified token budget'). With schema description coverage at 0%, the remaining four parameters (query, limit, scope, context_pack) receive no explanation at all. The description fails to clarify the semantics of key parameters like 'query' or 'scope,' leaving the agent to guess their meaning.

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

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

The description clearly states the tool's purpose: 'Search persistent project context for rules, decisions, conventions, and facts.' This provides a specific verb (search), resource (persistent project context), and types of content searched. The name 'ctx_search' naturally distinguishes it from siblings like ctx_get (retrieve specific) or ctx_save (store).

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

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

The description explicitly advises when to use the tool: 'Use this BEFORE writing code to understand project patterns and avoid inconsistencies.' This gives clear context and a specific scenario. However, it does not mention when not to use it or explicitly suggest alternatives among siblings, which would have made it a 5.

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

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

No annotations are provided, so the description carries the full burden. It describes what the tool returns (project info, key rules, etc.) but does not disclose behavioral traits such as that it is read-only, whether it has side effects, or any performance considerations. The description is adequate but could be more explicit about safety and behavior.

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

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

The description is two sentences: first sentence states purpose and use case, second lists included content. No filler words, front-loaded with the most important information. Highly efficient.

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

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

Given the tool has no parameters and an output schema is present, the description is fairly complete. It tells the agent what the summary contains and its intended use. It could mention that it is a read-only operation, but the output schema likely details the return structure. The description is sufficient for a simple tool.

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

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

The tool has zero parameters, so the input schema is trivial. The description adds value by listing the contents included in the summary (project info, key rules, etc.), which is beyond what the schema provides. Baseline for no parameters is 4, and the description meets that.

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

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

The description clearly states the tool's purpose: 'Get a compact project context summary for handoff between sessions or agents.' It specifies the verb (Get) and the resource (compact project context summary), and distinguishes it from sibling tools by mentioning it aggregates multiple aspects (project info, key rules, decisions, environment, recent session).

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

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

The description gives a clear use case: 'for handoff between sessions or agents.' This implies when to use it (transition times). However, it does not explicitly state when not to use it or compare it to alternatives like ctx_get or ctx_project, which would be helpful given the many sibling 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?

Annotations are absent, so the description must fully disclose behavior. 'Only provided fields are changed' hints at a partial update (patch semantics), but it does not state whether the update is atomic, what happens to unspecified fields, or whether validation occurs. No description of return values, even though an output schema exists.

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 short sentence with no fluff. It is front-loaded and readable. However, it is too terse to cover all necessary dimensions given the tool's complexity and missing annotations.

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

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

Given 5 parameters (including optional ones with defaults), 14 sibling tools, and no annotations, the description is too sparse. It does not explain the relationship to other tools, how partial updates work with nullable fields, or what the output schema provides. The description would benefit from covering prerequisites and behavioral nuance.

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. The only parameter-related info is 'Only provided fields are changed', which describes update behavior but adds no meaning to individual fields like memory_id, tags, content, confidence, or importance. Their default values and nullability are left unexplained.

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

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

The description states 'Update an existing memory', which indicates a mutation verb and a vague resource ('memory'). However, the resource is not specific enough among siblings like ctx_delete (deletion) or ctx_save (creation/overwrite). It leaves ambiguity about what 'memory' means in the context of a memory system with many other 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?

It provides no guidance on when to use this tool vs alternatives like ctx_save (which might create or overwrite) or ctx_delete. There is no mention of prerequisites (e.g., the memory must already exist) or scenarios where this is preferable.

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