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

With no annotations, the description carries the full burden and does well: it discloses the 50-call cap, 8-way concurrency, result ordering, and failure isolation ("ok=false with its error and never cancels its siblings"). It stops short of timeout behavior, recursion/nesting rules, and whether calls count against any quota.

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

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

Front-loaded with the core behavior, then usage, then failure semantics, then the exclusion — a sensible ordering with no filler sentences. It runs five sentences where four would do, and the readToolFile reference introduces noise.

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?

Covers usage conditions, limits, ordering, and partial-failure behavior, which is most of what an agent needs to call this safely. With no output schema, the description should say what a successful item looks like (it only documents the ok=false case).

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

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

Schema coverage is 100%, so the schema already documents the calls array and its server/tool/arguments members, making 3 the baseline. The description adds item shape and ordering semantics, but its claim that server and tool names are "the ones readToolFile shows" is at odds with the schema, which points to listToolFiles — a small ambiguity rather than clear added value.

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 ("Runs up to 50 tool calls in one bounded fan-out") plus the two defining traits: 8-way concurrency and input-order results. An agent can distinguish it from executeTool and from the file-listing siblings without opening the schema.

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

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

Gives an explicit use condition ("when several calls are independent - across servers or within one") and an explicit exclusion plus the alternative ("Do NOT use it when one call depends on another call's result: write an executeTool script"). Names the sibling to switch to.

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 and does so: it discloses the four security layers (validation, sandbox, timeout, Tool ACL), states that each call runs in a fresh isolated scope with no persistence, that print() is captured to logs, and that it returns {result, logs}. That is exactly the mutation/execution-risk context an agent needs.

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

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

Front-loaded with what the tool does, then workflow, then security, then syntax rules – a logical order with no filler sentences. It is dense and long for a one-param tool, but each block (workflow, ACL, Starlark rules) maps to a distinct failure mode an agent would otherwise hit.

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?

Despite having no output schema and no annotations, the description specifies the return shape ({result, logs}), the isolation model, the timeout bound, and the ACL gate. Nothing material is missing for an agent to call this 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?

Schema coverage is 100% and the single param's description already says to assign `result`, so the baseline would be 3. The description adds real value by constraining the code syntax (no imports/classes/try-except, % formatting, == not `is`, dict access via result["key"]), which genuinely shapes what goes into `code`.

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 ('Executes Python-like (Starlark) code in a sandboxed interpreter') plus the distinctive capability of calling MCP tools as Server.tool_name(param=value). Named siblings (listToolFiles, readToolFile, getToolDocs) are positioned in the workflow, so an agent can tell this apart from the discovery tools without opening any schema.

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

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

Gives an explicit ordered workflow: listToolFiles -> readToolFile -> (optional) getToolDocs -> executeTool, plus the operational instruction to read the stub first and use the exact callable name shown. It effectively names the alternatives and the precondition that selects this one over them.

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 present, so the description carries the burden; it discloses that both server and tool are required and shows the keying convention (server+tool) needed to address a doc record. It doesn't state whether unknown tool names error or return empty, which is the one behavioral gap for a lookup 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?

Three short sentences, front-loaded with what is returned before the routing condition. The inline server/tool example partly duplicates the schema's own examples, a small redundancy, but nothing is 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?

For a two-parameter documentation lookup with a fully described schema and no output schema, the description says what comes back (param descriptions, types, examples), when to use it, and what it requires. An agent has everything needed to call it correctly.

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

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

Schema description coverage is 100%, so both parameters are already documented with the same filesystem/read_file examples. The description repeats that both are required but adds no format, casing, or ambiguity-resolution guidance beyond the schema, so baseline 3 applies.

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

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

States a specific verb+resource ('Get detailed documentation for a specific tool') and enumerates what the output contains (full parameter descriptions, types, usage examples). It also explicitly contrasts with the sibling readToolFile's compact signature, so an agent can distinguish the two without opening a schema.

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

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

Gives an explicit trigger ('when the compact signature from readToolFile is not sufficient') and names the alternative tool that covers the other case. Nothing is left to inference about when to escalate from readToolFile to this tool.

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 so: it discloses that the files are virtual VFS stubs, the exact path shape for both server-level and tool-level binding, and the naming contract tying the filename stem to the callable name for executeTool. It also states the discovery scope limit (connected servers only) and the call syntax used downstream.

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

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

Front-loaded with the core statement, then workflow, then the invocation-syntax note; the ordering is good and no sentence is filler. The 'In code, call tools as Server.tool_name(param=value)' sentence drifts into executeTool's territory and is the one piece that could be trimmed or moved.

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?

Zero params, no output schema, and no annotations — so the description must supply everything, and it does: what is returned (path patterns per binding mode), how those paths map to callable names, and where this tool sits in the discovery sequence. Nothing needed to invoke it correctly is missing.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. The description does useful adjacent work by explaining that output shape varies by binding mode, but that is return-value context rather than parameter meaning.

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 ('Lists the virtual .pyi stub files for connected CodeMode MCP servers') and immediately explains the two binding modes that determine what gets listed. This clearly separates it from readToolFile, getToolDocs, and executeTool, which all operate on files this tool enumerates.

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 an explicit ordered workflow (listToolFiles -> readToolFile -> optional getToolDocs -> executeTool) plus a hard trigger: 'CALL THIS FIRST when the user names a server, tool, or capability not in your visible tool list.' It also supplies a negative rule — do not claim unavailability until this tool confirms it — which is exactly the when-not guidance agents need.

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 and does disclose key behavior: case-insensitive matching, optional .pyi extension, and that the returned signatures are authoritative for executeTool calls. It stops short of error behavior (what happens for an unknown fileName) and does not restate that the operation is non-mutating beyond the verb 'Reads'.

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

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

Front-loaded with the core action and path forms, then constraints, then the workflow sequence. Dense but every sentence carries information; the only mild redundancy is restating the two path shapes that also appear in the schema example.

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?

No output schema and no annotations, so the description must supply the return semantics, which it does ('returns the authoritative callable name and arguments'). Workflow and alternatives are covered; the remaining gap is failure behavior for an invalid or unlisted fileName.

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 baseline is 3, but the description adds semantics the schema lacks: fileName values must come from listToolFiles, matching is case-insensitive, and the extension is optional. startLine/endLine are covered by the schema descriptions, so no further description text is required.

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 ('Reads') and a specific resource (a virtual .pyi stub), and enumerates the two accepted path shapes (servers/<server>.pyi and servers/<server>/<tool>.pyi). It also names the sibling (listToolFiles) that produces valid inputs, so an agent can distinguish it from listToolFiles and getToolDocs immediately.

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 an explicit workflow chain: listToolFiles -> readToolFile -> (optional) getToolDocs -> executeTool, plus a concrete condition for escalating ('If the compact signature is insufficient, use getToolDocs'). Both when-to-use and when-to-use-an-alternative are stated.

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