Zerostel

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

With no annotations, the description carries the full burden. It discloses the effect (a restorable snapshot) and the reversibility via rewind, which is real value, but omits permissions, whether repeated calls overwrite prior checkpoints, storage cost, and idempotency.

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 tightly written sentences, front-loaded with the action and its rationale; the return-value note is a compact addendum. No wasted words.

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 single-parameter tool with no output schema, the description covers purpose, trigger timing, and the return value (step number). Only minor operational details are absent, which is acceptable at this complexity.

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

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

Schema description coverage is 100%, so the 'message' parameter is already documented as 'what is about to happen.' The description adds no additional meaning about this parameter, matching the baseline 3 when the schema does the heavy lifting.

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 (save a snapshot of the project files) and ties it to the rewind sibling via 'can be rewound to later.' It does not explicitly name a sibling to route against, but the purpose is unambiguous.

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

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

Gives clear timing context ('now, before doing something risky'), which tells the agent when to call it. No explicit when-not conditions or named alternatives are provided, but the risky-operation trigger is actionable.

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

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

No annotations are provided, so the description carries the full burden. It usefully implies a non-executing, read-only query ('would block... before trying it'), which is valuable safety context, but it says nothing about what the check returns, whether it evaluates reads vs writes differently, or what happens when no rules match.

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

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

One tightly written sentence that front-loads the purpose and ends with the actionable timing constraint. Nothing is redundant or padded.

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 annotations and no output schema, the description should ideally explain the return shape (allowed/blocked plus reason) and clarify non-execution more firmly. It covers purpose and timing adequately but leaves meaningful gaps for a safety-gating tool.

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

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

Schema description coverage is 100% and the single 'command' parameter is already documented in the schema as 'a shell command or a file path'. The description adds no syntax, format, or edge-case detail beyond that, so the baseline 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 pairs a specific verb ('Ask whether...would block') with a precise resource (the user's guardrail rules) and input scope (a shell command or path). It is clear on its own, but it never distinguishes itself from sibling tools like 'checks' or 'verify', which an agent could reasonably confuse it with.

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?

'before trying it' gives explicit timing guidance: this is a pre-flight check to run prior to executing a command. No alternative tool is named and no exclusion conditions are stated, so it stops short of full routing guidance.

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

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

With no annotations, the description carries the whole behavioral burden, and it does disclose the one non-obvious trait: results can be stale relative to the current code, which changes how a pass should be interpreted. It does not state that the operation is read-only/non-mutating, nor whether in-progress checks are included or how results are ordered, leaving some behavioral gaps.

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

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

Two sentences, front-loaded with what is returned and followed by the action guidance and its caveat. Every clause earns its place — the staleness rule in particular is load-bearing rather than filler.

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

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

There is no output schema, so the description must convey return contents, and it does: the categories of checks, per-check pass/fail, and the change-since-run flag. For a zero-parameter read tool this is complete enough to call 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 takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. The description correctly does not waste space restating parameter semantics.

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

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

The description enumerates the exact resource it reports on (tests, type checks, linters, builds run in this session) and the two facts returned per item: pass/fail and whether the code changed since the run. That scope — session run results plus staleness — cleanly separates it from siblings like verify, checkpoint, and timeline.

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 an explicit when-to-use trigger: 'Read it before saying the work is tested,' plus the decision rule that a pass on since-changed code doesn't count. It does not name an alternative tool (e.g., verify) or state when not to use this one, so it stops short of full routing guidance.

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

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

With no annotations, the description carries the full burden and does meaningfully disclose behavior: the default selection rule (latest session that changed files) and the important interpretation constraint that only user prompts are instructions while everything else is a record. It does not state whether the operation is read-only or has side effects, and no auth or rate-limit context is given, but the trust/instruction semantics are a genuinely valuable disclosure.

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

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

Two sentences, front-loaded with the core action and then a compact enumeration of contents, followed by the default and the instruction-vs-record caveat. Dense but every clause carries information; minor cost is the slightly abstract opening phrase.

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, so the description must convey what comes back, and it does so by listing the returned categories (prompts, file diffs, check status, dropped attempts, gaps). For a single-optional-param read-style tool this is largely complete; only the structural format of the return and any mutation/safety profile are 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?

Only one optional parameter exists and schema coverage is 100%, so the schema already documents 'session' fully. The description reinforces the default (latest file-changing session) but adds no syntax or format detail beyond the schema, so the baseline 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 uses a concrete verb-resource framing ('Pick up where an earlier session left off') and enumerates the specific payload it surfaces (user prompts, changed files, check status, discarded attempts, gaps). It is clear what the tool does, though it never distinguishes itself from siblings like timeline or checkpoint, which could plausibly also surface session history.

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 default behavior is stated ('Defaults to the latest session that changed files'), which implies the intended usage of resuming work. However, there is no explicit when-to-use vs when-not-to-use guidance and no routing to alternatives such as checkpoint or timeline, leaving the agent 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?

With no annotations, the description carries the full burden and delivers: it discloses the default preview-only behavior, the confirm-code safety gate, the destructive nature (files are changed), and importantly that the rewind is itself reversible. This is exactly the behavioral context an agent needs before mutating files.

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 dense sentences, front-loaded with the core action and step semantics, then the safety workflow, then reversibility. Every sentence carries distinct information with no padding or repetition.

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

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

For a tool with no annotations and no output schema, the description covers the action, the step semantics, the apply gate, and reversibility. It omits any hint of the preview output shape (though it names the confirm code) and the effect of 'after'/'keep_others', which are left entirely to the 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?

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning beyond the schema: it explains what '0' and 'undo' resolve to in practice and ties apply=true to the confirm-code workflow. It does not extend 'after' or 'keep_others', which 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?

States a specific verb and resource ('Put the project files back to how they were before a step'), and clarifies the 'step' values ('0' as point zero, 'undo' as before the last file-changing turn). It is unambiguous what the tool does, but it never explicitly differentiates itself from siblings like checkpoint or timeline.

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 explicit when-to-use and gating rules: it only previews unless apply=true, and requires the agent to obtain user request, show the preview, and pass the confirm code before applying. Nothing about the apply workflow is left 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?

No annotations are provided, so the description carries the full behavioral burden. "Show" does imply a read-only, non-mutating operation and the description discloses the return contents and the meaning of step numbers, but it says nothing about ordering, scope limits for long sessions, or what happens when no steps exist — gaps that matter for a history-viewing tool.

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

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

Two sentences with zero filler. The core purpose and contents come first, with the rewind interoperability note following as the secondary payload — well front-loaded.

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 (one optional numeric parameter, no output schema, read-only by implication), and the description covers what is returned plus the key semantic link to rewind. It is nearly sufficient, with only minor omissions around ordering and empty/oversized histories.

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 the single optional parameter 'last' is fully documented in the schema as "only the last N steps." The description never references it or adds syntax, defaults, or edge-case behavior (e.g., what 'last' does when N exceeds history), so it adds nothing 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?

Specific verb ("Show") plus a precisely scoped resource ("recorded steps of the current session") and an enumeration of what those steps contain: prompts, tool calls, files changed. It also ties itself to the sibling 'rewind' by explaining that the step numbers it emits are rewind's input, so an agent can position it in the toolset 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?

Usage is implied rather than stated: the rewind cross-reference hints at the inspect-then-rewind workflow, but there is no explicit "use this when you need to inspect history before rewinding" and no distinction from checkpoint or checks, which are plausibly overlapping 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?

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only integrity check, but never discloses what a failure looks like, what the return value is, whether it is expensive, or what the agent should do if verification fails.

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 well-formed sentence that front-loads the verb and states the exact condition being verified. No filler.

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

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

For a zero-param read-only check the scope is adequately stated, but with no output schema the description should say what result the agent gets back (pass/fail, details of tampering). That gap keeps it at minimum-viable.

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, so there is nothing for the description to disambiguate. Baseline 4 applies; the description correctly implies the implicit target (the current session's log).

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 (check/verify) applied to a specific resource (the current session's log) with the exact property being validated (no edits since recording). This is clear and mostly self-differentiating, though the sibling 'checks' could still cause minor hesitation.

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 indication of when to invoke this versus 'checks', 'check_policy', or 'timeline', and no prerequisites or context for the verification (e.g., after rewind or before handoff). The agent must infer the trigger condition.

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