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

Annotations already declare readOnlyHint and openWorldHint, and the description aligns with them by saying 'Read...'. It adds useful behavioral context beyond annotations, including the bounded nature of messages, pagination via beforeCursor, and visibility into provider errors and requests for human attention. No contradiction exists.

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

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

The description is four short sentences, front-loaded with the core read purpose and with no filler or redundant phrases. Each sentence earns its place by adding either scope, sibling routing, pagination, or input-response context.

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

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

Given the simple read-only operation and the presence of readOnlyHint and openWorldHint annotations, the description covers the main purpose, pagination, and sibling routing. However, it lacks explanation of required parameters like environmentId and threadId, and its reference to 'T3' is unexplained, leaving some gaps for an agent unfamiliar with the domain.

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

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

Schema description coverage is 0%, so the description must compensate for the four parameters. It mentions beforeCursor and loosely implies a limit with 'bounded recent messages', but it does not describe threadId, environmentId, or turnLimit, leaving required identifiers and the limit parameter underspecified.

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 bounded recent messages, activity, current status, provider errors and requests for human attention.' This clearly defines what the tool returns and distinguishes it from list_threads, which is explicitly named for discovering thread IDs.

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 actionable guidance: 'Discover thread IDs with list_threads' names the alternative for a related task, and 'Older turns can be paginated using beforeCursor' explains how to handle pagination. It stops short of explicit exclusions for sibling tools like send_message or interrupt_thread, so it is clear but not fully exhaustive.

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 mark the tool as destructive and non-idempotent, and the description adds valuable behavior beyond that: interruption is a 'request', and the target turn is recorded so a retry cannot accidentally interrupt a later turn. This is a useful, non-obvious behavioral guarantee.

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 concise sentences with no filler. The first sentence states the core action and target; the second adds a crucial retry-safety detail. Both sentences earn their 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 destructive, non-idempotent operation with no output schema, the description covers the most important operational details: what is interrupted, how the target is selected, and how retries behave. It omits side effects or prerequisites, but the core calling context is sufficiently clear.

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

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

Schema description coverage is low at 25%, and the description only partially compensates. It clarifies that the turn can be 'current' or 'explicitly selected,' which maps to the optional turnId, and it reinforces the retry behavior tied to operationId. However, environmentId and threadId are not explained in the description.

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

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

The description states a specific action ('request interruption') and a clear resource ('the current or explicitly selected turn'). This makes the tool's purpose unambiguous and immediately distinguishes it from siblings like start_thread, get_thread, and send_message.

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 clear context for when to use the tool: it targets either the currently running turn or an explicitly selected turn. It does not explicitly list alternatives or exclusions, but the selection guidance and the retry caveat convey the operational context well enough.

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 and openWorldHint, so the description does not need to reiterate those. It adds value by explaining availability probes are optional and bounded to the current page, which is a behavioral detail not present in annotations. This complements the safety profile.

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 redundancy. The main purpose is front-loaded, and the additional probe note is directly relevant. Every word earns its place.

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

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

For a simple list tool with annotations covering safety, the description is adequate but not complete. It fails to mention that limit and offset are pagination controls, and with no output schema, an agent may be unsure about return structure. The page-bounded probe detail helps, but more could be said.

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 0% schema description coverage, the description must compensate for all parameters. It only addresses checkAvailability indirectly via 'availability probes', leaving limit and offset completely unexplained. An agent would not know their purpose or how they control pagination from the description alone.

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

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

The description uses the specific verb 'List' with a clear resource ('machines') and scope ('linked to the signed-in T3 account'), which distinguishes it from sibling list_projects. It also adds a clarifying note about availability probes, leaving no ambiguity about what the tool does.

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

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

The description implies usage for listing machines but does not explicitly state when to choose this over alternatives like list_projects. No exclusions or alternative guidance are provided, though the note about optional availability probes gives some usage context.

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

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

Annotations already declare readOnlyHint and openWorldHint, covering the safety profile. The description adds useful context that results include model defaults and that exactly one environment is selected, going beyond annotations. However, it does not mention pagination behavior, ordering, or error handling for invalid environments, so the added behavioral context is minimal.

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 no filler. It states the verb, resource, and scoping condition directly, and every word 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?

For a simple read-only list tool, the description provides the essential call context: one environmentId, projects with model defaults, and no mutation. The lack of output schema and pagination guidance leaves some details to inference, but the tool's basic nature and optional parameters are adequately understood from schema defaults and the generic 'list' framing.

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

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

Schema description coverage is 0%, so the description must compensate for documenting parameters. It maps 'explicitly selected environment' to the required environmentId parameter, which is helpful. However, limit and offset are completely unmentioned, leaving their defaults, bounds, and purpose underspecified despite the schema having no descriptions either.

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 ('List') and names the resource ('projects and their model defaults'), with a clear scoping qualifier ('on one explicitly selected environment'). This differentiates it from sibling tools like list_environments, which targets environments rather than projects. No ambiguity remains about what the tool does.

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

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

The phrase 'on one explicitly selected environment' clearly communicates that this tool should be used when an environment is already chosen, and that the caller must supply an environmentId. It does not explicitly name alternatives or when-not-to-use conditions, but the context is strong enough for a read-only list operation. A small gap is that it doesn't point users to list_environments as the way to discover valid environments.

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?

Even with readOnlyHint=true, the description adds meaningful behavioral context: only unarchived threads are returned, results are ordered newest-activity-first, pages are bounded, and 'finished' status means the latest turn completed, not verified task success. This goes well beyond the annotation's safety signal.

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 sentences, each earning its place: scope and output fields, optional filters, ordering/pagination, a pointer to get_thread, and a status clarification. No filler 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 5-parameter tool with no output schema, it describes the returned fields, ordering, pagination, filtering, and sibling handoff. It does not discuss error/empty-result behavior or explicit parameter names, but the essentials for correct invocation and interpretation are present.

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

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

Schema description coverage is 0%, so the description compensates by explaining environmentId (one environment), projectId and status as optional filters, and pagination via 'bounded pages' and 'Newest activity first.' It does not expand every status enum value or name limit/offset explicitly, but the main parameter semantics are covered.

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: 'Discover unarchived threads on one environment' with the returned fields (IDs, titles, status, flags, timing). It also distinguishes itself from siblings by framing this as the listing/discovery operation, with get_thread pointed to separately for reading messages.

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?

Provides clear context for when to use the tool (discovering threads, with optional project/status filters) and explicitly routes the agent to the sibling get_thread for reading messages. It does not enumerate exclusions for other siblings like interrupt_thread or start_thread, but the primary alternatives are addressed.

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 mutation and destructiveness, and the description usefully adds that it may change files, incur charges, and that operationId plus arguments must be preserved for retries. These are meaningful behavioral details beyond the annotations, though the description does not deep-dive into what files might change or the failure/return behavior.

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

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

Three short sentences, each adding distinct information: what the tool does, side effects, and retry guidance. There is no redundant phrasing and the core purpose is 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?

Given the tool's four required parameters and lack of output schema, the description covers side effects and retry requirements, which are the most critical operational concerns. It does not describe the return value or error/timeout behavior, but for a straightforward message-sending tool this is an acceptable minor 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 documentation covers only operationId, and the description mostly reinforces that instead of adding meaning for the other three required parameters. instructions is implicitly mentioned via 'instructions,' but environmentId and threadId get no meaningful elaboration despite low schema coverage, so the description does not compensate for the missing parameter documentation.

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

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

The description uses a specific verb and resource: 'Send follow-up instructions' in an existing thread. It is clearly distinguishable from sibling tools like start_thread or get_thread by emphasizing 'the thread's existing model and runtime modes.'

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 'follow-up instructions' and 'existing model and runtime modes' establishes that this tool is for continuing work in an already-started thread, not for listing environments or projecting new threads. It does not explicitly name alternatives or state when not to use it, but the context is clear enough.

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?

Beyond the annotations, it discloses concrete side effects: changing files, incurring provider charges, default approval requirement, lack of worktree support, and retry semantics for operationId. This goes well beyond the readOnly/destructive flags. No contradiction with annotations.

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?

Five short sentences each add distinct information, with the core purpose first. No filler or redundant restatement of the schema.

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

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

The description covers side effects, defaults, limitations, and retry behavior, but with 8 parameters, low schema coverage, and no output schema, an agent still lacks guidance on return values, model selection, interaction mode, and how the IDs relate. It 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 only 13% (only operationId is documented), and the description compensates minimally. It implies the instructions parameter and notes the approval-required runtimeMode default, but it doesn't explain environmentId, projectId, title, modelSelection, or interactionMode. With low schema coverage, the description should carry more of this burden.

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 the specific verb-resource pair, 'Create a thread and send instructions to its agent,' and situates it in the existing project workspace. This clearly differentiates it from sibling tools that list environments/projects or send messages to an existing thread, even though those siblings aren't 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?

It provides clear context: the thread is created in the existing project workspace, defaults to approval-required, and cannot create worktrees. It also gives retry guidance. However, it does not explicitly identify which sibling to use instead, so it stops short of the 5 level.

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