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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered without the description. The description adds little beyond that: 'reports actual versions and boundaries' hints at diagnostic output but does not describe the return shape, failure modes (e.g., adapter not installed), or what 'boundaries' means concretely.

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?

Three short sentences, front-loaded with the use case, then the reported content, then the exclusions. Every sentence carries distinct information with no repetition of the name or 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?

For a single-parameter read-only diagnostic tool with no output schema, the description covers purpose, scope, and exclusions adequately. The only meaningful gap is the unexplained project_path parameter, which the schema also leaves undocumented.

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 single parameter, project_path, is never explained in the description. An agent must guess whether it is a filesystem path, an absolute vs relative path, or a project identifier, and what happens if it does not exist. The description does not compensate 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?

States a specific verb (inspect) and specific resource (the installed Ruflo/Codex adapter and its project store), plus what it reports: actual versions and boundaries. This is clearly distinguishable from the memory_*/task_* siblings, which are all data-mutation or task-lifecycle 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?

'Use to inspect...' frames the intended context, and the explicit negatives ('Does not launch agents or modify Codex settings') prevent a common mis-invocation. No alternative tool is named, but no sibling covers this adapter-diagnostic purpose, so the exclusion is the only routing guidance needed.

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 already flag destructiveHint=true and readOnlyHint=false, so the safety profile is conveyed structurally. The description adds isolation-by-project_path context and a note about runtime backend reporting, but stays silent on what happens when the key is absent and whether deletion is recoverable — meaningful gaps for a destructive mutation.

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?

Core action and lookup semantics are front-loaded in the first sentence. The trailing clause about runtime embedding/storage backend is somewhat tangential to a delete operation, keeping it below 5.

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 destructive tool, the description covers scope and isolation, and annotations handle the safety signal. However, with no output schema, the description should say what a successful delete returns or how a missing key is handled; it does neither.

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

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

With 100% schema description coverage the schema already documents all three parameters, including the namespace default and the 'absolute path to existing project directory' constraint. The description's phrase 'exact (namespace, key)' adds the matching-semantics nuance but little else. Baseline 3 applies.

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

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

States a specific verb and resource ('Remove a stored memory entry') and pins the lookup mode to 'exact (namespace, key)', which implicitly separates it from the fuzzy memory_search sibling. It never names a sibling explicitly, so it falls 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?

'Use for project-scoped persistent memory. Never import personal memory automatically' gives some scoping context, but never says when to prefer this over memory_store/memory_search or whether a lookup should precede deletion. Usage is implied rather than prescribed.

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 already cover read-only, non-destructive and closed-world behavior, yet the description still adds real context: isolation by project_path, no automatic import of personal memory, and that the runtime reports the actual backend. The last clause is vague but the isolation caveat is genuinely useful.

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?

Three short sentences, front-loaded with purpose and the semantic-search exclusion. The trailing 'runtime reports actual embedding and storage backend' is slightly off-topic for a list operation and dilutes an otherwise tight description.

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?

A read-only list tool with a fully documented 5-parameter schema and an explicit safety profile is largely self-describing; the description contributes the isolation model and filtering scope. Pagination behavior is left to the schema, which is acceptable 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 100%, so tags, namespace, limit and offset are already documented in the schema. The description only restates the namespace/tags filtering at a high level and adds no format or semantics beyond 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?

States a specific verb and resource ('Enumerate stored memory entries') and explicitly distinguishes itself from semantic lookup with 'without semantic search', which separates it from the memory_search sibling.

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

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

Gives a clear usage context ('project-scoped persistent memory') and the implicit contrast with semantic search, but stops short of naming memory_search or memory_retrieve as the alternatives an agent should pick instead.

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 already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds real behavior beyond that: results are lossless, metadata is included, storage is isolated per project_path, and the runtime surfaces the actual embedding/storage backend — useful for trusting the result's provenance.

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 action and lookup mode, then alternatives and constraints, with no filler. The trailing clause about runtime-reported embedding/backend is slightly cryptic but still earns its place as provenance 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?

With no output schema, the description does state the return is lossless and carries metadata, plus the isolation guarantee. It stops short of saying what happens when the key is absent (empty result vs. error), which is the one behavior an agent would still have 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 coverage is 100%, so the schema already documents all three parameters, including project_path isolation. The description's only addition is that matching is exact rather than fuzzy, which is meaningful but thin; the project-isolation note largely restates the schema.

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

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

States a specific verb and resource ('Read back a value previously stored via memory_store') and pins the lookup mode as exact (namespace, key), which cleanly separates it from the semantic-oriented memory_search sibling. An agent can pick between the two without opening either 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?

Gives clear context ('Use for project-scoped persistent memory') and one explicit exclusion ('Never import personal memory automatically'). It does not explicitly name memory_search/memory_list as the alternative when exact match is not known, leaving that routing to inference from the word 'exact'.

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 already establish read-only, non-destructive, closed-world behavior. The description adds meaningful behavioral context beyond annotations: project_path isolation, a warning against automatic personal-memory import, and that runtime reports the actual embedding and storage backend.

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 and front-loads the core semantic-search concept with a concrete example. The policy sentence about personal memory is somewhat separate from invocation semantics but still earns its place as a guardrail.

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 seven-parameter read-only search tool with rich schema descriptions and no output schema, the description provides enough conceptual context to call it correctly: semantic matching, project isolation, and backend reporting. It remains slightly incomplete because it does not route the agent among retrieval siblings.

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

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

Schema description coverage is 100%, so all seven parameters are already well documented, including smart, threshold, namespace, and provenance_filter. The description reinforces the semantic nature of query and project_path isolation but adds little parameter-level detail beyond the schema, making the baseline 3 appropriate.

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 — find stored memories — and clearly specifies semantic/vector similarity rather than literal text matching, with a useful example. It does not explicitly name or distinguish itself from retrieval siblings such as memory_retrieve or memory_list, so sibling differentiation is only implicit.

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 contextual usage guidance ('Use for project-scoped persistent memory') and a policy warning ('Never import personal memory automatically'), but does not state when to choose this over sibling tools like memory_retrieve, memory_list, or memory_stats. The usage context is implied rather than comparative.

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 already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds useful behavioral context that data is isolated by project_path and that runtime reports the actual embedding/storage backend, but the phrasing is terse and it does not describe the shape of the statistics returned.

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 content is short, but the sentences run together without punctuation ('...HNSW index status Use for...'), which hurts front-loading and readability. The final sentence mixes two ideas (isolation and runtime backend reporting) in one clause.

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 read-only stats tool with no output schema, the description covers the essential points: what is measured (storage stats, HNSW index status) and the isolation/backend caveats. An agent has enough to call it correctly, though the return shape is only loosely implied.

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?

Only one parameter exists and schema description coverage is 100%, so the schema already explains project_path in detail (absolute path, isolated Ruflo store). The description reinforces isolation by project_path but adds no syntax or format beyond the schema, making 3 the baseline.

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

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

States a specific verb+resource: 'Get memory storage statistics including HNSW index status'. This is clearly distinguishable from siblings like memory_store, memory_search, and memory_list. It does not, however, explicitly name a sibling it is not, so it falls 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?

'Use for project-scoped persistent memory' hints at the scenario but never says when to pick this over memory_list or memory_search. 'Never import personal memory automatically' is a constraint rather than usage guidance, and no when-not conditions 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?

Annotations already declare the write/non-destructive profile, and the description adds real context beyond them: cross-session persistence, vector-based searchability, per-project_path isolation, and the note that the runtime reports the actual embedding/storage backend. It doesn't state what happens on key collision (the schema's upsert default carries that) or any size/rate limits.

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?

Four short sentences, front-loaded with the core capability and followed by usage constraints. The closing clause about runtime reporting the backend is useful but slightly tangential to the call decision.

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 an 8-parameter write tool with no output schema, the description covers purpose, isolation, and safety boundaries but says nothing about conflict/overwrite outcome, growth limits, or the shape of a successful response. Adequate given the rich schema, but there are residual gaps an agent would hit at call time.

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

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

Schema description coverage is 100%, so every parameter including upsert, ttl, namespace, provenance_type, and project_path is already documented in the schema. The description adds only the isolation semantics of project_path and the meaning-search consequence of the stored value, so it sits at the baseline.

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

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

States a concrete resource (persistent key-value store with vector embedding) plus the two traits that distinguish it from sibling tools — survives across sessions and is searchable by meaning rather than key/path. It never names memory_search or memory_retrieve explicitly, so routing relies on inference, but the capability boundary is legible.

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?

"Use for project-scoped persistent memory" gives a clear when-to-use, and "Never import personal memory automatically" is an explicit exclusion. It stops short of naming the alternative siblings (memory_search for retrieval, memory_delete for cleanup), so an agent must infer the split.

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 already declare a non-destructive write, but the description adds real value beyond them: it states the tool stores metadata only and does not start or execute an agent, and it explains per-project store isolation via project_path. It does not disclose that the unassign flag wipes all agent assignments, which is a notable omission 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 short sentences with no filler, and the negative constraint about not executing an agent lands early. The colon construction ("...Codex sessions: assign") reads awkwardly, but 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 4-parameter write tool with no output schema, the description covers the non-obvious behavior an agent needs: metadata-only semantics, no execution side effect, and project-scoped isolation. The missing piece is the effect of unassign and whether repeated assignment is idempotent.

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

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

Schema description coverage is 100%, so all four parameters are already documented with meaning. The description reinforces project_path isolation but adds no new semantics for taskId, agentIds, or the unassign flag beyond what the schema states. Baseline 3 applies.

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

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

The verb "assign" is given but the object is never stated outright — an agent must infer from the schema that it assigns agent IDs to a task. The second clause ("Stores task metadata only; does not start or execute an agent") does clarify what the tool is not, which separates it from an execution-style sibling, but the core action is left implicit.

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?

"Use when tracking persistent work across Codex sessions" gives a usage context, but there is no guidance on when to choose this over task_update, task_create, or task_complete, all of which are adjacent metadata-writing siblings. The reader is left to infer the boundary.

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 already indicate a non-destructive write operation. The description adds valuable context: it stores task metadata only and does not start or execute an agent, and it is isolated by project_path. These details help an agent understand the scope and side effects, though it doesn't cover state requirements or response format.

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, but the first sentence is awkwardly structured and not front-loaded with a clear action verb. The second sentence is clear, but the overall flow could be improved for an agent scanning for purpose.

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

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

For a cancellation tool, it covers the metadata-only nature and project isolation, but it omits important details such as what happens to an already running task, whether cancellation is reversible, or if the task must be in a certain state. With annotations and full schema coverage, the description is adequate but has clear gaps.

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

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

Schema coverage is 100%, so the schema fully documents all parameters. The description's note about isolation by project_path reinforces the schema but adds little new meaning. With the schema doing the heavy lifting, the baseline of 3 is appropriate.

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 says 'cancel' but does not explicitly state that it cancels a task. The phrase 'Use when tracking persistent work across Codex sessions: cancel' is vague and does not follow a clear verb+resource pattern. The tool name helps, but the description alone is only minimally clear about what is being cancelled.

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 implies a context for use ('when tracking persistent work across Codex sessions') but does not name alternatives like task_complete or task_update, nor does it specify when not to use this tool. The note about not executing an agent adds some guidance, but the overall usage direction is implied rather than explicit.

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

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

Annotations already indicate it is non-read-only, non-destructive, and closed-world. The description adds that it stores task metadata only, does not start or execute an agent, and is isolated by project_path. It does not disclose idempotency, side effects, or what state transition 'complete' causes.

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 and front-loads the usage context, with no filler. The phrasing 'sessions: complete' is awkward, and 'Isolated by project_path' largely repeats schema 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?

For a mutation tool with annotations and fully described parameters, it covers the non-execution nature and path isolation. It still omits what completion does to task state, whether it triggers downstream behavior, and how the optional result object is used.

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

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

Schema description coverage is 100%, so taskId, project_path, and result are already documented in the schema. The description only echoes the project_path isolation behavior and adds no new parameter-level guidance, making the baseline of 3 appropriate.

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 'complete' but never explicitly states that it marks a task as completed or precisely what resource is affected. The metadata-only clarification distinguishes it from agent-execution tools, but it remains ambiguous relative to siblings such as task_update and task_cancel.

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 a usage context ('when tracking persistent work across Codex sessions') and rules out using it to start or execute an agent. However, it gives no explicit when-not guidance or alternatives for task_cancel, task_update, or other task lifecycle 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 already declare non-read-only, non-destructive, closed-world. The description adds genuine value beyond them: it stores metadata only with no agent execution, and writes are isolated per project_path so tasks don't leak across stores.

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?

Three short, front-loaded sentences with no filler. The sentence fragment 'create.' is slightly terse but the when-to-use clause leads, which is the right ordering.

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 6-param creation tool with full schema coverage and no output schema, the description covers trigger, side effects, and scoping adequately. It omits what the call returns (e.g., a task ID), which is a minor gap given no output schema exists.

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

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

Schema coverage is 100% and every parameter is described in the schema, including the project_path isolation note. The description only reinforces the project_path scoping, adding little beyond structured fields, so baseline 3 applies.

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

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

States a specific verb (create) and resource (task) plus the persistence scope across Codex sessions. The clause 'stores task metadata only; does not start or execute an agent' sharpens what kind of creation this is, though no sibling (task_update, task_assign) is explicitly named.

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?

'Use when tracking persistent work across Codex sessions' gives a clear trigger, and 'does not start or execute an agent' rules out a plausible misread. It stops short of naming alternatives like task_update or task_assign for related flows.

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 already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds genuinely new behavior: it stores metadata only, never launches an agent, and results are isolated per project_path. It doesn't cover the limit cap of 200 or ordering of results, which would have made it a 5.

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?

Three short clauses, front-loaded with the use condition, then the behavioral constraint, then the scoping rule. Nothing is redundant or 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 read-only filtered list with full schema coverage and no output schema, the description covers purpose, safety, and scoping adequately. A brief note on what the returned task records contain, or that the limit defaults to something below 200, would close the remaining 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 description coverage is 100%, so all six parameters including filters and the limit are already documented in the schema. The description reinforces project_path isolation but adds no syntax, format, or interaction detail beyond what the schema states, so baseline 3 applies.

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

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

The description names the resource (tasks) and the operation (list) and scopes it to persistent work tracked across Codex sessions. It also explicitly excludes agent execution, which separates it from task_create/task_assign-style siblings, though it does not name task_summary or task_status as 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?

"Use when tracking persistent work across Codex sessions" gives a clear triggering context, and the note that it does not start or execute an agent tells the agent one thing this tool is not for. No sibling is named as the preferred alternative when the goal is a single task lookup or a summary.

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 already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false. The description adds useful behavioral context by stating it stores metadata only, does not execute an agent, and is isolated by project_path, though it does not elaborate on side effects of resetState beyond the schema.

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

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

The description is short and front-loads the usage context and key behavioral caveats. Its phrasing is somewhat terse and awkward ("...sessions: retry"), but it avoids unnecessary 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?

With full parameter coverage, annotations, and no output schema, the description covers safety and execution boundaries reasonably well. It still omits key retry semantics, such as whether retrying creates a new task, updates the existing one, or how it interacts with resetState.

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

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

Schema description coverage is 100%, so taskId, resetState, and project_path are already documented. The description reinforces project_path isolation but adds little parameter-level meaning beyond what the schema provides.

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 names the action as "retry" and clarifies that it stores task metadata only rather than executing an agent. However, it does not explicitly say what retrying a task means in terms of task creation/state, so the purpose remains somewhat vague despite the tool 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?

It gives a broad usage cue ("Use when tracking persistent work across Codex sessions") and an exclusion ("does not start or execute an agent"). It does not distinguish this from siblings such as task_create, task_update, or task_complete, leaving the agent to infer when retry is appropriate.

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 already declare readOnlyHint=true and destructiveHint=false, so safety is covered; the description adds real context beyond that with "Stores task metadata only" and "Isolated by project_path." It still omits behavior an agent would want, such as what happens when taskId does not exist or whether unstarted tasks are reported differently, so it goes beyond the minimum but not substantially.

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?

Three short clauses, usage condition front-loaded, no filler. The fragmentary style ("...sessions: status.") is slightly awkward and costs a little clarity, but every sentence contributes distinct 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?

For a two-parameter read-only tool with no output schema, the description should say what a status actually contains (state, timestamps, assignment) since nothing else does. It covers scope, storage, and isolation adequately but leaves the return semantics and error behavior unstated.

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

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

Schema description coverage is 100%, so both taskId and project_path are documented in the schema, including the isolation semantics of canonical paths. The description only echoes the isolation point ("Isolated by project_path") and adds no format or validation detail beyond the schema, which is the correct baseline-3 outcome when structured fields already do the work.

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 reads as a lookup of task status keyed by taskId, but the core phrase is a bare noun ("status") rather than a specific verb+resource statement. The clarifying clause ("Stores task metadata only; does not start or execute an agent") usefully separates it from task_assign/task_retry, but the exact operation (read a task's current status) has to be inferred from the name and required params.

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?

"Use when tracking persistent work across Codex sessions" gives a situational trigger, and the negation "does not start or execute an agent" implicitly routes execution to task_assign/task_retry. However, no sibling is named explicitly and there is no guidance on when to prefer task_summary, task_list, or task_update instead, which matters given the crowded task_* family.

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 already declare readOnlyHint=true and destructiveHint=false, yet the description says the tool "Stores task metadata only", which implies state mutation and sits uneasily with the read-only declaration. The remaining content ("does not start or execute an agent", isolation by project_path) is genuinely useful side-effect context, but the storage claim muddies the safety profile rather than clarifying it.

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?

It is short, but the opening sentence is malformed ("...sessions: summary") and the key disambiguating fact, that it only touches metadata and never runs an agent, is buried in the second clause. The framing needs to lead with what the tool does, not with a usage fragment.

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

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

There is no output schema and the description says nothing about what a "summary" returns — fields, aggregation scope, or empty-state behavior. For a tool whose entire value is the summary payload, an agent cannot predict the result before calling it.

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

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

With a single parameter at 100% schema coverage, the schema already documents project_path fully, including the per-path isolated store. The description's "Isolated by project_path" merely echoes that statement and adds no format, default, or failure-mode nuance.

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?

"Use when tracking persistent work across Codex sessions: summary" never states what the tool actually does — it reads as a restatement of the name followed by a dangling label. The only concrete clause, "Stores task metadata only; does not start or execute an agent," clarifies scope by negation rather than defining the operation, and nothing distinguishes it from siblings like task_status or task_list.

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?

"Use when tracking persistent work across Codex sessions" gives a usable usage context. However, no alternative is named and no when-not-to-use condition is offered, even though task_status and task_list are obvious candidates that would need 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, openWorldHint=false, so mutation and safety profile are covered. The description adds genuinely new behavioral context: it is metadata-only, never triggers agent execution, and writes are isolated per project_path store. Missing only what happens to omitted fields on update.

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?

Three short, front-loaded sentences with no filler; the usage trigger comes first and the behavioral constraints follow. Every clause carries 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?

With no output schema, six parameters, and a nested result object, the description leaves some gaps: it does not clarify whether omitted fields are left unchanged, how assignTo relates to the sibling task_assign tool, or what the call returns. Adequate but not fully complete for a mutation tool of this shape.

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

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

Schema description coverage is 100%, so every parameter including the status enum and the nested result object is already documented in the schema. The description contributes only the project_path isolation note, which is meaningful but already echoed in the schema text, so baseline 3 applies.

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

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

The description gives a specific verb ('update') on task metadata and clearly scopes the resource as persistent work tracked across Codex sessions. The clause 'stores task metadata only; does not start or execute an agent' separates it from execution-oriented siblings like task_assign and task_retry, though no sibling is named directly.

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 supplies a usage context ('when tracking persistent work across Codex sessions') and one negative boundary (does not start or execute an agent). However, it never states when to prefer task_update over task_assign, task_complete, or task_cancel, which overlap meaningfully with the status/assignTo parameters.

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