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

With no annotations, the description carries the burden of behavioral disclosure. The verb 'check' and 'report' imply a non-mutating diagnostic read, which is useful. However, it does not explicitly state side-effect-free behavior, return format, or what happens when no providers are installed. For a parameterless, likely safe tool, the core behavior is covered but not deeply.

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 sentence that front-loads the action ('Check') and clearly states the output ('report its version'). There is zero fluff; every word earns its place.

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

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

For a simple, parameterless tool with no output schema, the description is nearly complete. It tells the agent what will happen and what the result will be. The only missing context is clarification of what 'supported providers' means and whether this is a safe/read-only operation, though 'check' strongly implies 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?

The tool has zero parameters, so the input schema is empty. Per the baseline for 0-parameter tools, the description need not explain parameters. It correctly references 'each supported provider' as a fixed scope, adding no 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 clearly states a specific action ('Check whether each supported provider CLI is installed') and a concrete result ('report its version'). It is unambiguous and distinguishable from sibling tools like 'providers' or 'status' because it focuses on installation/version diagnostics.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, typical scenarios (e.g., diagnosing environment setup), or exclusions. The purpose is clear, but the agent is left to infer when 'doctor' is appropriate among 16 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 full responsibility. It discloses the read nature and the permission model, but it does not mention that mark_read can mutate state (mark messages as read). This is a behavioral gap, as an agent might assume a purely read-only operation despite the parameter hinting at a side effect.

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 primary purpose is stated first, followed by the access 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?

For a tool with 3 parameters, no output schema, and no annotations, the description is incomplete. It fails to explain mark_read and unread_only, and does not describe the return format. An agent would be guessing on how to use the tool effectively.

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 explain all parameters. It only explains agent_id (and who needs it), leaving mark_read and unread_only completely undefined. The agent cannot know what these booleans do without external knowledge, which is a significant deficiency.

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

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

The description clearly states the tool's function ('Read persisted messages') and distinguishes it from sending tools like send and message_send. It also specifies the resource (messages) and the context for who can read what, which sets it apart from siblings.

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 explains when agent_id must be specified (external supervisors) and implies it's optional for managed agents. This gives concrete usage guidance, though it doesn't explicitly name alternatives or state 'use this when you need to read messages' – but that is clear from the verb 'read'.

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 of behavioral disclosure. It states the core action (cancel/stop) and a permission restriction, but does not mention side effects, reversibility, or behavior when the target does not exist. This is a destructive operation, so more transparency is warranted.

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, tightly worded sentence that front-loads the action and includes a relevant caveat. It contains no filler or redundant phrasing.

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 sparse for a destructive tool. It does not explain return values (no output schema), error conditions, or what happens to dependent jobs/sessions. The restriction on managed callers is stated but the behavior for unmanaged callers is left ambiguous. Given the one-parameter signature and absence of annotations, more context is needed.

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

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

The schema has zero description coverage, and the description does not elaborate on the parameter. However, 'agent_id' is self-explanatory in the context of killing an agent, and the tool name and description imply its purpose. It is a single, simple parameter, so the minimal guidance is acceptable but not compensatory.

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

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

The description clearly states the tool cancels an active job and stops a session, with a specific verb and resource. It also adds a restriction about who may call it, distinguishing it from monitoring tools like status or wait.

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 mentions a constraint for managed callers but does not explicitly state when to use this tool versus alternatives or when not to use it. There is no guidance on checking status before killing or using other tools for related actions.

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 burden of behavioral disclosure. It does reveal a non-obvious behavior: visibility is role-dependent (managed agents see only their team; external supervisors see all). Yet it doesn't mention read-only status, output details, ordering, or error behavior, which are relevant but not critical for a simple list operation.

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

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

The description is two sentences with no wasted words. The core function is front-loaded, and the role-based visibility nuance adds real value without bloating the definition.

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 tool with a straightforward purpose, the description covers what the tool does and who can see what. The lack of an output schema isn't fully compensated by the description, but for a simple list tool this is a minor gap rather than a critical omission.

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 no parameters, so the schema imposes no burden. With zero parameters, the baseline is 4, and the description doesn't need to add parameter-level detail.

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 ('List') and the resource ('visible sessions'), making the tool's function immediately understandable. The 'visible' qualifier and role-based scope help differentiate it from sibling tools like team_list or status, though it doesn't explicitly name an alternative.

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

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

The description implies when to use the tool—when you need to see sessions—and adds useful role-based context about who sees which sessions. However, it does not explicitly state when not to use it or mention any sibling alternatives, leaving some routing 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 burden of disclosing behavior. It states the mutation (mark as read) but does not disclose whether the operation is idempotent, whether it requires authentication, what happens for invalid IDs, or the impact on other state. The word 'mark' implies a state change but lacks depth.

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, clear sentence that is front-loaded with the action and object. It contains no filler or redundancy, making it highly efficient.

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

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

For a simple mutation tool, the description provides the core action but omits details like return value, error handling, idempotency, and permission requirements. Given the absence of an output schema and annotations, an agent might not know what to expect after calling it. However, the simplicity of the tool (single parameter, straightforward action) keeps the gaps moderate.

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 should compensate. It implies the 'message_ids' parameter by saying 'one or more inbox messages', which aligns with the schema's minItems=1 and maxItems=100. However, it does not explicitly name the parameter or clarify its format (e.g., string identifiers). The description adds some meaning but not enough to fully cover the parameter's 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 uses a specific verb ('Mark') and resource ('inbox messages as read'), which clearly conveys the tool's function. It distinguishes itself from siblings like 'inbox' (which likely lists messages) and 'send'/'message_send' (which create messages) by focusing on the read-state mutation.

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

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

No guidance on when to use this tool versus alternatives. It does not mention that it should be used after viewing messages, nor does it exclude cases like marking messages as unread (which might be another tool). The description only states the action, leaving usage context 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, the description carries the full burden and does disclose the key behavior: the message is persisted, and wake=true conditionally starts a new turn. However, it omits side effects like delivery guarantees, recipient state requirements, or whether failures can occur silently.

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 core action is front-loaded, and the wake behavior is presented as a conditional add-on, making the tool's behavior easy to parse quickly.

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 a mutation with no annotations, no output schema, and 0% parameter coverage. The description does not explain return values, error conditions, or how this differs from the sibling 'send' tool, leaving an agent with notable gaps when deciding to call 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?

Schema description coverage is 0%, so the description must compensate. It clarifies wake's conditional behavior and the general notion of an attributed message, but gives little explicit semantics for to_agent_id and message beyond their names.

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 ('Persist') and resource ('attributed message to another agent'), making the core action clear. It does not explicitly distinguish itself from the sibling tool 'send', but the persistence and attribution framing separates it at a basic level.

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 wake=true behavior but gives no guidance on when to use this tool versus alternatives like 'send' or 'message_ack'. There is no mention of prerequisites, conditions, or cases where a sibling would be 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 full burden of behavioral disclosure. It states the operation is a list and that the output includes the CLI command expectation, which implies a read-only, non-mutating action. However, it does not explicitly confirm side-effect-free behavior, error conditions, or any rate limits, leaving a minimal but acceptable gap.

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, compact sentence front-loads the verb and object and adds the relevant detail about the CLI command. No filler, redundancy, or unnecessary words are present.

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 zero-parameter, read-only listing tool with no output schema, the description conveys the core purpose and what the output contains. It lacks any mention of usage context or relationship to sibling tools, but the description is functionally sufficient for an agent to call the tool 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, so the empty input schema is fully covered. The description adds relevant context about the returned data, but since there are no parameters to explain, the baseline of 4 for zero-parameter tools 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 ('List') and resource ('provider adapters') and adds a defining detail about the CLI command each adapter expects. It is clear and specific, but it does not explicitly distinguish itself from the generic sibling 'list' tool, 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?

The description provides no guidance on when to use this tool versus alternatives like 'list' or other sibling tools. There is no mention of context, prerequisites, or exclusions, leaving the agent without direction on tool selection.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says to 'get' a result, but does not explain behavior for pending, failed, invalid, or inaccessible jobs, nor what the result contains or whether the operation is read-only. The word 'accessible' promises a condition but never elaborates on 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?

The description is a single focused sentence with no filler, tautology, or redundant detail. It front-loads the action and resource and stays appropriately minimal for a tool with one parameter.

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

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

The tool has no annotations and no output schema, so the description must compensate. It does not explain the return value, error cases, job lifecycle, or when a result is 'accessible.' Given sibling tools like wait and status, more context is needed for an agent to correctly sequence calls.

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%, but the description explicitly references 'by job ID,' which maps directly to the single required job_id parameter. For a one-parameter tool, this is sufficient semantic clarification, even though it does not describe format conventions or value provenance.

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: 'Get an accessible job result by job ID.' It clearly identifies what the tool does and ties it to the only input, distinguishing it from siblings like status, list, or wait. The word 'accessible' hints at a scoping condition, but the core 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?

The description gives no guidance on when to use this tool versus alternatives such as status, wait, or list. The only implicit signal is that the caller must already have a job_id, but there is no stated workflow, no exclusion, and no mention of prerequisites or when the result becomes available.

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 does disclose that only idle sessions are targetable and that managed callers are team-limited, but it omits key behavioral traits such as side effects of sending a prompt (e.g., session becoming active, executing actions), error behavior for non-idle sessions, and permission requirements beyond the team restriction.

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 efficient sentence with no filler, and it front-loads the core action and constraint. It is appropriately terse, though it sacrifices detail for brevity.

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 no annotations, no output schema, and 0% schema parameter coverage, the description should provide enough context to invoke the tool correctly. It gives a broad purpose and a team restriction, but lacks parameter meanings, return behavior, error conditions, and relationships to sibling tools, leaving significant 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 description coverage is 0%, so the description must compensate by explaining the two parameters. It does not mention 'prompt' or 'agent_id' at all, leaving the agent to infer meaning solely from the parameter names. This fails to provide any added semantic clarity.

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 ('Continue') and resource ('existing idle provider-native session'), clearly distinguishing it from sibling tools like 'spawn' (creation) and 'message_send' (likely messaging). It does not explicitly name alternatives but the focus on 'existing idle' sessions makes the purpose fairly 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?

Usage is implied: use this tool when an existing idle provider-native session should be continued. However, it does not explicitly state when not to use it or contrast with siblings such as 'message_send' or 'spawn', so the guidance is minimal.

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 disclosure burden. It does usefully disclose asynchronous execution and the managed-caller child-team behavior, but it omits other important behavior such as side effects, resource implications, failure modes, or how to retrieve the spawned session's output.

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 tight sentences with no filler, front-loading the core action and the key asynchronous trait. Every clause adds some signal, making it efficient and scannable.

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 complexity—11 parameters, no output schema, no annotations—the description leaves too much undefined for reliable invocation. The managed-caller behavior is a useful detail, but the overall definition is incomplete for an operation that creates a coding-agent session.

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 description adds no meaning to any of the 11 parameters. 'First job' loosely hints at prompt, but provider, access, workspace, team_id, parent_agent_id, effort, role, and model are entirely unexplained, so the agent gets no parameter-level help.

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 ('spawn'), resource ('coding-agent session'), and the asynchronous start behavior, so an agent can grasp the main action. It does not explicitly contrast with the sibling spawn_many, but the singular 'a coding-agent session' makes the single-session scope clear enough.

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

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

No guidance is given on when to choose spawn over spawn_many, send, or wait, nor when not to use it. The managed-callers note offers a small usage hint, but there is no explicit routing or alternative-selection 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 must disclose behavior. It covers concurrency (sequential start, concurrent jobs) and the limit of 16, but omits critical aspects: whether it blocks, what happens on partial failure, side effects on the workspace, authentication requirements, or return format. For a tool that spawns multiple agents, these are significant 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?

The description is two sentences, no wasted words, and states the most important detail (concurrency) early. It is appropriately concise, though a bit more detail would be warranted given the complexity.

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 a nested array schema, no annotations, and no output schema, the description is woefully incomplete. An agent cannot know what to put in the 'agents' array, what the expected response is, or how failures are handled. It does not even mention that each element is an agent configuration object.

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 explain the 'agents' array and its nested fields. It does not mention that each agent requires 'provider' and 'prompt', nor the meaning of optional fields like 'cwd', 'access', 'workspace', or 'model'. The description adds zero parameter meaning beyond the raw 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 purpose: spawning up to 16 coding-agent sessions. The verb 'spawn' with the resource 'coding-agent sessions' is specific. It distinguishes from the sibling 'spawn' by implying multiple sessions, but it does not explicitly name the alternative, so it misses the top score.

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

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

There is no guidance on when to use this tool versus the sibling 'spawn' or other session-management tools. The description mentions sequential start and concurrent jobs, which hints at behavior but not usage context. No exclusions or alternatives are stated.

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 reveals it is a read operation (get), but does not state whether it requires authentication, whether it might return partial data if the agent is busy, or what happens if the agent is not accessible. No contradictions, but significant 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?

A single, concise sentence with no fluff. It directly states the action and the object. Perfectly front-loaded and minimal.

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 getter with one param and no output schema, the description is mostly sufficient. However, it lacks context on what 'latest job' means, whether the output includes status fields, or if there are any side effects. Given the tool is read-only, a 3 is fair; it's adequate but missing minor details.

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

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

The schema has 0% description coverage for the parameter, so the description must compensate. The description does not explain 'agent_id' beyond naming it, but the parameter name is self-explanatory (an ID string). This is mediocre compensation; more detail like 'the ID of the agent to query' would help but isn't critical.

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 it fetches an accessible agent and its latest job, which is specific and distinguishes it from siblings like 'list' (which likely lists agents) and 'result' (which may fetch job results). However, it could be more specific about what 'accessible' means or what a 'job' entails.

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 siblings like 'status' vs 'doctor' or 'whoami'. It implies it is for checking status, but does not mention alternatives or exclusions. For example, it doesn't say 'use doctor for diagnostics' or 'use whoami for current user'.

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 of behavioral disclosure. It only states the creation of a team, but does not disclose side effects, permissions required, idempotency, or what happens on success or failure. This is minimal for a mutating operation.

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

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

The description is short and front-loaded with the core action, but it is under-specified. While concise, it does not earn its brevity because key information about parameters and usage is missing.

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 no annotations, no output schema, and zero parameter coverage, the description is severely incomplete. It does not explain parameters, return values, prerequisites, or any operational context. An agent would struggle to call this tool correctly without additional information.

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. It does not mention either 'name' or 'supervisor_agent_id' at all, leaving their meaning and relationships unexplained. The description adds no value beyond the parameter names themselves.

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 verb 'Create' and a specific resource 'top-level logical team', distinguishing it from sibling tools like team_status and team_list which are read-only. It also adds context about availability to external control-tower hosts, which is a useful constraint.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions availability to external control-tower hosts, which is a constraint rather than usage guidance. No exclusions or explicit 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?

With no annotations provided, the description carries the full burden. It discloses a non-obvious behavioral trait: returned teams depend on the caller's role ('Managed agents see their own team; external supervisors see all teams'). For a read-only list with no parameters, this is meaningful transparency, though it does not describe output 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?

Two short sentences, front-loaded with the core purpose. The role-based detail is delivered efficiently with no filler, and each sentence contributes essential 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 zero-parameter list tool, the description explains what is listed and the visibility rules. There is no output schema, so a slight gap exists around return format, but the operation is simple enough that the description is largely 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 has zero parameters, and the instructions give a baseline of 4 for parameter-free tools. The description adds role-based filtering context, which is relevant to interpreting what the (empty) input means.

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 ('List visible teams'), making the tool's purpose immediately clear. It also adds the role-based scoping distinction (managed agents vs. external supervisors), which differentiates it from generic sibling tools like 'list' and 'team_status'.

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 useful context about who sees which teams, implying when the tool is appropriate, but it does not explicitly mention alternatives or when not to use it. Sibling tools like 'team_status' or 'list' are not referenced, leaving the agent to infer the correct selection.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It adds the managed agent limitation, which is useful, but it does not explicitly state the operation is read-only (implied by 'Get'), nor does it mention error behavior or response format. The description adds one behavioral constraint but lacks broader 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 concise, consisting of two sentences with the primary purpose stated first. It is front-loaded and contains no extraneous information, making it easy for an agent to quickly understand the tool's function.

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

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

The tool has only one parameter and no output schema, so the description should provide enough context for correct invocation. It explains the main function and the managed agent limitation, but it does not describe the structure of the returned data (e.g., what 'members' includes) or any error conditions. For a simple get tool, it is mostly adequate but missing details that could affect how the agent interprets results.

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

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

The input schema has 0% description coverage, so the description must compensate for the team_id parameter. It does not explain what team_id refers to, what format it should take, or that it's the identifier for the team. This is a significant gap since the schema only provides a type and minLength.

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

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

The description clearly states 'Get a team and its members' with a specific verb (get) and resource (team plus members). It distinguishes itself from sibling tools like team_list (list teams) and team_create by focusing on retrieving a single team with its members.

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 mentions 'Managed agents are limited to their own team,' which provides a usage constraint but does not explicitly guide when to use this tool versus alternatives. It implies that managed agents should use this for their own team, but it doesn't state when not to use it or suggest other tools.

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

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

With no annotations, the description must carry the behavioral burden. It adds useful details beyond the schema, such as returning early when all jobs are terminal and a 60-second timeout cap. However, it does not disclose what happens when the timeout expires, what the return value contains, or whether waiting has side effects.

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

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

The description is a single sentence with no filler, front-loading the core action and then adding the key behavioral constraint. 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?

This is a simple two-parameter tool, and the description covers the essentials of waiting and early return. However, without an output schema or annotations, the absence of timeout-expiration behavior and return-value semantics leaves a meaningful gap for an agent deciding whether the call succeeded.

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. It maps job_ids to 'one or more jobs' and relates timeout_ms to the 60-second cap, but it leaves out the default timeout, the unit context, and how zero or missing timeout_ms should be interpreted.

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 ('wait for'), a clear resource ('one or more jobs'), and a precise completion condition ('returning early when all are terminal'). This distinguishes it from sibling status-checking tools like status and result by making the blocking behavior 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 description clearly implies the use case: block until jobs reach a terminal state rather than polling status or fetching results. It does not explicitly name alternatives or exclusion conditions, but the purpose is unambiguous enough for an agent to select 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 full burden of behavioral disclosure. It states the return value (identity or 'managed=false'), which implies a read-only operation, but it does not explicitly mention that it has no side effects, requires no permissions, or cannot fail. For a simple identity query, this is acceptable but not exhaustive.

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, compact sentence that front-loads the core function ('Return the managed agent identity') and immediately clarifies the edge case. Every word contributes value, with no redundant phrasing or 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-parameter tool with no output schema, the description fully specifies what the tool does and what it returns. It covers both the managed and unmanaged cases, leaving nothing missing for an agent to call it correctly. The simplicity of the tool means no further context is needed.

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 schema fully covers everything (coverage 100% trivially). Per calibration, a baseline of 4 applies since there are no parameters to document. The description adds no parameter-specific meaning because none exist, which 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 clearly states the tool's purpose: returns the managed agent identity inherited by the MCP process, with a fallback for external hosts. It uses a specific verb ('Return') and resource ('managed agent identity'), leaving no ambiguity about what it does. This distinguishes it from sibling tools like 'status' or 'list', which handle other concerns.

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 you need to know the managed agent identity or whether the host is managed. However, it does not explicitly mention alternatives or when not to use it. Sibling tools like 'doctor' or 'status' might cover similar diagnostics, but no exclusions or comparative guidance is provided, keeping this at a basic clear-context level.

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