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

There are no annotations, so the description carries the full behavioral disclosure burden. It only says 'Record', implying a write, but does not disclose side effects such as supersedes retiring a prior decision, immutability, or what happens on success. That is thin 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 with the verb and object leading. There is no filler, and every word contributes to the core message.

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 full input schema and an output schema, the definition is minimally viable for a simple logging tool. It is incomplete because it offers no explicit alternative selection guidance and no behavioral context about the supersedes relationship, but the schema and output schema lower the burden significantly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces the rationale aspect of summary but adds no new meaning for location or supersedes beyond what the schema already documents.

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 a specific action ('Record') and a specific resource ('architectural/product decision') and ties in the rationale requirement. This clearly communicates the tool's purpose, though it does not explicitly differentiate it from sibling recording tools such as add_note, log_issue, or record_attempt.

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 when-to-use or when-not-to-use guidance is given. The description does not tell the agent to prefer add_decision for decisions and log_issue for issues, or how to handle events that supersede prior decisions; the agent must infer all selection context from the tool name and sibling 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, the description carries the full burden, but it only says 'Record' without disclosing whether this creates a new entry, appends to a store, or has side effects. It does not mention idempotency, persistence location, or what happens if the same location is reused.

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, focused sentence that front-loads the verb and includes concrete content types; there is no filler or redundant wording.

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 two-parameter tool with an output schema, the core behavior is clear, but the absence of guidance for choosing among overlapping sibling tools leaves a real gap. Since annotations are absent and the description is minimal, the definition is only minimally 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?

The schema already fully documents both parameters ('The note content' and 'file:line or component'), so the baseline is 3. The description adds examples of what kind of content the summary should hold, which is a small improvement over 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?

The description states a clear action ('Record') and a specific resource (a note) with content categories: gotcha, setup detail, or durable context. It does not explicitly contrast sibling tools, but the categories give enough substance to identify the tool's role.

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 there is a gotcha, setup detail, or durable context to store, but it does not say when to prefer add_note over log_issue, record_attempt, record_fix, or add_decision. No exclusions or conditions are provided, leaving the agent to infer selection criteria.

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 does state 'Read-only,' which is a meaningful safety disclosure, and 'token-budgeted... biased toward failures and decisions' hints at selection behavior. However, it does not explain how the token budget truncates content, how the bias is applied, or whether the block is derived from a live or cached 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 two short sentences with no filler. The first sentence is information-dense, and the second provides a safety-relevant flag. 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?

The tool is simple and all parameters are documented, and an output schema exists, so the description need not repeat return formats. However, it leaves ambiguities: what counts as 'failures' and 'decisions,' how the token budget shapes the result, and how this context block relates to the many sibling context tools. It is adequate for a basic call but not fully complete for tool selection.

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%: focus, tokens, and recent_days already have individual descriptions. The tool description adds no parameter-specific meaning beyond reinforcing the token-budget concept, so the 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 a concrete resource ('context block') and a specific selection bias ('failures and decisions'), plus a token-budgeting mechanism. It is clear about what the tool returns, but it does not explicitly contrast with sibling tools like get_summary or get_project_map, so it stops short of full differentiation.

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

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

The description implies this is the tool to use when you need a token-limited summary focused on failures/decisions, but it gives no explicit when-to-use or when-not-to-use guidance. It does not mention alternatives or conditions that would make another sibling tool more 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?

No annotations are provided, so the description carries the behavioral disclosure burden. It explicitly states 'Read-only' and explains that auto-promotion is off and entries come from explicit curation, giving useful context about data provenance and governance. This is strong but not exhaustive; it does not discuss error cases or filtering behavior beyond what the schema already provides.

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 with the core purpose, followed by a single relevant governance note. Every sentence contributes meaning, and there is no redundant 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?

For a simple read-only tool with an output schema and one optional parameter, the description is largely complete. It clarifies the data source, read-only nature, and curation governance. A small gap remains in explicitly guiding an agent on when to prefer this tool over sibling getters, but the core invocation context 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 input schema has 100% description coverage for the single optional 'library' parameter, including that it filters by substring. The description adds no parameter-level meaning beyond what the schema already documents, so the baseline score 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 states a specific verb and resource: 'Read cross-project gotchas from the shared global store.' This clearly identifies what the tool does and differentiates it from sibling tools like get_issue or get_context by focusing on cross-project gotchas in a global 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 implies the tool should be used when cross-project gotchas are needed, but it does not explicitly state when to use it versus alternatives or mention any exclusions. It provides context about governance but no direct routing guidance, so usage remains 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?

No annotations are provided, so the description carries the full behavioral disclosure burden. It explicitly states 'Read-only' and indicates this loads mandatory rules, making the tool's side-effect profile clear. It could add more about error handling if the file is missing, but this is minor.

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 the key action and resource in the first sentence and usage guidance in the second. Every word earns its place with no redundancy.

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

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

For a zero-parameter read-only tool with an output schema available, the description supplies all necessary context: what it loads, that it is safe, and when to call it. Nothing critical 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 tool has zero parameters and schema description coverage is 100%, so there is nothing for the description to add beyond the schema. The baseline of 4 applies here since parameter semantics are trivially complete.

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 verb ('Load') and resource ('the project's mandatory AI workflow rules (AI_INSTRUCTIONS.md)'). This is easily distinguished from sibling tools like get_summary or get_global_gotchas, which serve different purposes.

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 says to call this tool 'at session start,' which provides clear timing guidance. It does not mention alternatives or exclusions, but the stated usage context is strong enough for an agent to know when to invoke 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?

With no annotations provided, the description carries the behavioral burden. It explicitly states "Read-only", which is a valuable safety disclosure for an agent. It also indicates that the full history is returned; output schema can cover return-structure 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?

Two short, purposeful sentences with no filler. The core action is front-loaded, and the read-only and token-efficiency notes add valuable context 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 one-parameter read-only tool with an output schema, the description is nearly complete. The main gap is that the summary alternative is only referenced obliquely as "the whole summary" rather than explicitly pointing to the get_summary sibling.

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%: the single param issue_id already has a clear description with format guidance (zero-padded 4-digit ID). The tool description adds no extra parameter semantics, so the baseline score of 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 clearly states the action and resource: "Read one issue's full history". It also signals read-only semantics and hints at a contrast with the broader summary, but it does not explicitly name the sibling tool (get_summary), so sibling differentiation is present but not fully 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?

The phrase "token-efficient vs the whole summary" gives useful context: this tool is the lighter-weight way to get one issue's history instead of the full summary. It does not state explicit when-to-use or when-not-to-use rules, but the intended use case is reasonably clear.

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 burden and explicitly states 'Read-only,' which signals safety. It also discloses the exact return value when plan.md is not initialized, giving the agent useful edge-case awareness beyond a simple 'read plan' statement.

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

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

The description is two short sentences with no filler. The first sentence front-loads the verb, resource, and content; the second adds the edge case and read-only nature. 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?

For a zero-parameter, read-only tool with an output schema present, the description sufficiently covers what is read, what content it returns, and the not-initialized case. No critical operational detail is missing for an agent 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?

The tool has zero parameters and the schema already covers 100% of them, so the description is not required to explain parameter behavior. The baseline for a no-parameter tool is satisfied.

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 'Read' and names the exact resource 'plan.md', then defines the content as 'the team's intent (ideas, active plans, next steps).' This is clear and distinct from generic read tools, though it does not explicitly contrast with siblings like get_summary or get_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 implies it should be used when an agent needs the team's current plan or intent, and it covers the 'not initialized' edge case. However, it does not explicitly say when to prefer this tool over sibling read tools such as get_instructions or get_context, nor does it state 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?

With no annotations, the description carries the full burden; it explicitly discloses that the operation is read-only and that it returns 'No project map found.' when not initialized. This covers side-effect safety and a key edge case, though it doesn't detail the returned layout structure beyond that.

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, each adding value: the action, the missing-file behavior, and the read-only guarantee. No filler, though 'Read-only' is slightly redundant with 'Read'.

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 definition is complete for executing a no-parameter read operation, but it lacks selection guidance relative to the many sibling read tools. It doesn't say when to prefer this over get_context or get_summary, which is a notable gap given the sibling list.

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 takes zero parameters and schema coverage is 100%, so there are no parameter semantics for the description to clarify. Baseline 4 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 clearly states the action ('Read') and the target resource ('the structural layout (PROJECT_MAP.md)'), making the tool's purpose unambiguous. It doesn't explicitly compare against siblings like get_summary or get_context, but the resource name provides enough distinction.

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 choose this tool over siblings such as get_context, get_summary, or get_plan. It only describes what the tool does, leaving selection to inference.

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 explicitly states the tool is read-only and computed from events.jsonl on each call, which signals no side effects and fresh computation. This is valuable transparency, though it does not mention authentication, rate limits, or error conditions; these are less critical for a zero-parameter read-only 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 extremely concise: two sentences, no filler, with the core purpose front-loaded. Every phrase adds information: the score's nature, formula disclosure, read-only behavior, and data source. This is an appropriately sized description for a simple tool.

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

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

For a zero-parameter read-only tool with an output schema available, the description provides the essential invocation context: what it returns, that it is read-only, and that it reads from events.jsonl. It lacks a bit of context about what 'failure-prevention' means and when it should be used, but the low complexity and presence of an output schema keep it reasonably 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?

The tool has zero parameters, so the baseline is 4. The description does not need to add parameter meaning. The statement about being computed from events.jsonl provides useful context about the score's derivation, which is sufficient.

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

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

The description clearly identifies a specific resource: a failure-prevention score, and notes that its formula is disclosed. It is distinguishable from sibling tools by the 'score' concept, though it does not explicitly explain what the score measures. Overall, the purpose is clear and specific enough for an agent.

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 sibling tools like get_summary, get_issue, or get_plan. It only states that the score is computed from events.jsonl, which implies a dependency on event data but does not specify conditions or alternatives. An agent would have to infer appropriate usage.

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 explicitly states that small memories return the full file while larger summaries return a bounded digest instead of silently truncating, and it explains the rationale ('client-side truncation would silently hide older entries'). This gives the agent a clear mental model of what to expect.

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 in the first sentence, then adds one crucial conditional behavior. Every sentence earns its place, and the structure is clean: what it does, then what happens in the edge case. No filler or redundancy.

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

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

For a zero-parameter read tool with an output schema, the description is largely complete: it defines the resource, explains the primary return behavior, and covers the size-budget edge case with actionable pointers. It could be slightly more complete by clarifying the relationship to get_context, but that is a minor gap given the low complexity and existing output schema.

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

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

The tool has zero parameters, and the schema coverage is 100%, so there is nothing for the description to add regarding parameter semantics. Per the rubric, zero parameters warrants a baseline of 4. The description adds no parameter-related confusion.

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 a specific verb and resource: 'Read the distilled project memory (summary.md)'. This clearly identifies what the tool does and references a concrete file, distinguishing it from tools like get_project_map and get_instructions. However, it does not explicitly contrast itself with get_context or other sibling tools, so differentiation is implied rather than stated.

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 explains the conditional behavior when the summary exceeds the size budget and mentions follow-up tools like get_issue/search_events, which is useful operational guidance. However, it does not explicitly state when to prefer this tool over alternatives such as get_context or get_plan, nor does it provide explicit when-not-to-use guidance. Usage context is implied but not fully spelled out.

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

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

With no annotations, the description carries the behavioral burden. It discloses that a new issue is created and marked active, which is useful side-effect information. However, it does not address potential duplicates, persistence, permissions, or reversibility.

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. The core purpose is front-loaded, and the workflow instruction follows immediately. 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?

The tool is simple with only two flat parameters and an output schema available. The description gives the key invocation context ('before writing fix code'). It is nearly complete, though the lack of annotations leaves some behavioral assumptions implicit.

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%, and the schema already explains both parameters ('One-line bug description' and 'file:line or component'). The tool description adds no additional parameter-level meaning, so the baseline score of 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 uses a specific verb and resource: 'Open a new issue' and 'mark it active.' This clearly distinguishes it from read-oriented siblings like get_issue and from post-fix tools like record_fix.

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 'Call BEFORE writing fix code' explicitly states when the tool should be used in the workflow. It does not name alternatives or exclusions, but the timing guidance is clear enough to guide selection among siblings.

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

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

With no annotations provided, the description carries the full burden, and it explicitly states 'Read-only,' which is the key behavioral disclosure. It also clarifies what the check covers. It does not discuss error behavior or permission requirements, but for a simple read-only precheck with an output schema, this is adequate.

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

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

The description is two short sentences with zero fluff: it front-loads the action, specifies scope and timing, enumerates what the check surfaces, and ends with the read-only safety note. Every phrase contributes meaning.

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

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

Given a single parameter, an output schema, and the explicit 'Read-only' declaration, the description is complete enough for an agent to select and invoke the tool correctly. It captures what the tool checks, when to use it, and its safety profile. No critical gap is evident.

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%: the single parameter file_path is already described as a 'Project-relative file path to check.' The description adds context about what checking means, but it does not add new semantic details about the parameter itself beyond the schema. 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 states a specific verb ('Check'), a clear resource ('a file's memory'), and the intended timing ('before modifying it'), then lists the concrete things it surfaces: open issues, failed and partial attempts, stale decisions, churn. This also distinguishes it from siblings like get_issue or get_context, which are more general reads. The 'Read-only' tag further clarifies its nature.

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 'before modifying it' gives an explicit usage condition: use this when you are about to modify a file. It does not explicitly name alternatives or say when not to use it, but the instruction is clear enough to route an agent to this tool for pre-modification checks.

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 conveys useful behavioral rules (immediacy, one approach per call), but it does not disclose side effects such as whether the attempt record is persistent, append-only, or editable later.

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 filler: the first front-loads the action and timing, the second adds a decisive batching rule. 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?

With the output schema present and all parameters documented, this is nearly complete for a simple logging tool. It lacks only a quick pointer to when record_fix or log_issue should be used instead, and the absence of annotations leaves persistence behavior implicit.

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%, and each parameter already has a meaningful description (outcome values, summary purpose, issue_id format, location format). The description adds only general call-granularity context, not per-parameter detail, so 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 names a precise action and object—record a fix attempt—and adds scope with 'after it fails, partially works, or works' and 'each distinct approach is its own call.' This is specific enough for an agent to distinguish attempt logging from generic issue/note 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 clearly states when to call ('IMMEDIATELY after...') and gives an explicit anti-pattern ('never batch them'). It does not name sibling tools such as record_fix or log_issue, so it stops short of a full when-to-use vs. alternative 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 behavioral burden. It discloses that the tool closes the issue and requires evidence, which is useful. However, it does not mention whether the action is reversible, what other side effects occur, or how it interacts with scoring or previous attempts.

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 with no filler. The first sentence communicates the action and target, and the second adds an important usage constraint. 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?

The description is adequate for a simple mutation tool: it says what it does and when to call it, and the schema and output schema cover the rest. It could add detail about finality or consequences, but nothing critical is missing for an agent to invoke it safely.

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%, and each parameter already has a meaningful description in the schema. The tool description adds no parameter-level detail, but the schema fully documents the parameters, so the baseline score 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 states a specific action ('Record the confirmed fix') and its consequence ('close the issue'), which clearly identifies the tool's purpose. It also differentiates the tool from siblings like record_attempt by emphasizing 'confirmed fix' and issue closure.

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 an explicit condition for use: 'Only call with evidence (test passed, error gone, or user confirmed).' It provides clear context for when the tool applies, though it does not name alternative tools or describe when not to use it apart from the evidence requirement.

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 clearly states the operation is read-only, describes the ranking criteria, and explains that an empty result returns a friendly message rather than an error. This is strong behavioral 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 two sentences with no filler. It front-loads the core action and packs in useful information about ordering, empty-result behavior, and read-only status. Every clause 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 read-only search tool with a fully documented schema and an output schema, the description covers purpose, behavior, and result ordering. It only lacks explicit usage context or alternatives, which keeps it from being fully 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?

The input schema already describes all three parameters with 100% coverage, so the description does not need to add parameter details. The mention of file-path hits and relevance ranking slightly enriches the query semantics, but the schema handles most of the burden. A 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 starts with a specific verb and resource: 'Search the event log'. It also explains the relevance ordering, so an agent knows exactly what the tool does and how results are ranked. No sibling tool is described as an event-log search, making its purpose distinct.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. It does not mention situations where a sibling tool like get_context or get_issue would be more appropriate, leaving the agent to infer the use case.

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