Server Quality Checklist

Tool Scores

• set_notebook_directoryC
  2.9/5.0
  Behavior2/5

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

  Annotations are present (readOnlyHint=false, destructiveHint=false, idempotentHint=false), and the description describes a write operation, consistent with annotations. However, it adds no extra behavioral context, such as whether the directory is created if missing or if validation occurs, which limits transparency.

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

  Conciseness3/5

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

  The description is short with three sentences, but some redundancy exists between 'All subsequent notebook operations will use this directory' and 'Useful for specifying where notebooks should be saved and loaded from'. It could be more compact.

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

  Completeness3/5

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

  Given the tool's simplicity (single parameter, no output schema), the description covers the basic purpose and effect. However, it omits details like whether the directory must already exist, if it's session-scoped, or if it affects existing operations, leaving minor gaps.

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

  Parameters2/5

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

  The schema has one required parameter 'path' with 0% description coverage. The description does not elaborate on its format, examples, or allowed values, providing no added meaning beyond the schema.

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

  Purpose4/5

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

  The description clearly states the tool sets the working directory for notebook operations, effectively communicating its function. However, it could better distinguish from `get_notebook_directory` by emphasizing the 'set' aspect, though the verb 'Set' already does so.

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

  Usage Guidelines3/5

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

  The description explains that subsequent notebook operations will use this directory and that it's useful for saving/loading, offering some guidance on when to use. It lacks explicit when-not-to-use or alternatives, but the context is clear.

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

• kernel_interruptA
  3.5/5.0
  Behavior3/5

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

  Annotations already provide readOnlyHint, destructiveHint, and idempotentHint. The description adds that the tool stops execution, which is a behavioral trait not fully captured by annotations. However, it does not disclose more nuanced behaviors like the effect on kernel state or whether interruptions can be stacked.

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

  Conciseness5/5

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

  The description is extremely concise: two sentences that correctly front-load the purpose and usage. Every word is necessary; there is no fluff or unnecessary detail.

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

  Completeness2/5

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

  Given the tool has one required parameter with no explanation and no output schema, the description should clarify the parameter. The current description leaves ambiguity about what 'name' refers to, making it incomplete for effective use.

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

  Parameters1/5

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

  The only parameter, 'name', has no description in the schema (0% coverage). The tool description does not mention the parameter at all, leaving the agent to guess what 'name' refers to (e.g., kernel name, cell name). This is a critical omission.

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

  Purpose5/5

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

  The description clearly states that the tool sends an interrupt signal to the running kernel to stop long-running or infinite-loop cell execution. The verb 'send' and resource 'interrupt signal' are specific, and the purpose is distinct from sibling tools like kernel_restart or kernel_start.

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

  Usage Guidelines4/5

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

  The description explicitly says when to use the tool: 'to stop a long-running or infinite-loop cell execution.' This provides clear guidance. However, it does not mention when not to use it or list alternatives (e.g., kernel_restart for a full restart), which would strengthen the score.

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

• notebook_deleteA
  3.6/5.0
  Behavior3/5

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

  Annotations already indicate destructiveHint=true and idempotentHint=true. The description adds the kernel shutdown behavior, which is useful but doesn't cover reversibility or error conditions. No contradictions 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.

  Conciseness5/5

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

  The description is concise: two sentences, front-loaded with the primary action, and no unnecessary words. Every sentence adds value.

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

  Completeness4/5

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

  For a simple delete tool with one parameter and no output schema, the description covers the main action and a key behavior (kernel shutdown). It lacks error handling details but is largely sufficient given the annotations.

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

  Parameters3/5

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

  With 0% schema coverage, the description adds meaning by noting that the .ipynb extension is optional, which clarifies the 'name' parameter. However, it doesn't specify whether the name should be a filename or full path, limiting completeness.

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

  Purpose5/5

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

  The description clearly states the tool's action: delete a notebook file and shut down its kernel. It differentiates from sibling tools like notebook_create or notebook_list by specifying the deletion and kernel shutdown. The optional extension note adds clarity.

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

  Usage Guidelines2/5

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

  The description does not provide guidance on when to use this tool versus alternatives, nor does it mention prerequisites (e.g., notebook must exist) or when not to use it. This lack of context makes it harder to choose among siblings.

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

• remote_disconnectA
  3.6/5.0
  Behavior1/5

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

  The description states 'All running remote kernels are shut down', indicating a destructive side effect, but annotations set destructiveHint to false. This contradiction results in a score of 1.

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

  Conciseness5/5

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

  Two concise sentences that front-load the primary action and add essential detail. No wasted words.

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

  Completeness4/5

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

  For a simple tool with no parameters, the description covers purpose and key behavior. It could mention prerequisites like being connected, but overall adequate.

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

  Parameters4/5

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

  There are no parameters, and schema coverage is 100%. The description does not add parameter info, but baseline for 0 parameters is 4, and no additional detail is needed.

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

  Purpose5/5

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

  The description clearly states the verb 'Disconnect' and the resource 'remote Jupyter Server', and distinguishes from siblings like remote_connect by explicitly mentioning the action and its side effect of shutting down remote kernels.

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

  Usage Guidelines3/5

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

  The description implies when to use (to disconnect and return to local kernels), but lacks explicit guidance on when not to use or alternatives. It states the shut-down effect, which provides context but no exclusions.

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

• notebook_execute_allA
  3.7/5.0
  Behavior4/5

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

  Annotations are all false, so the description provides necessary behavioral details: stop_on_error behavior, skipping non-code cells, and return of summaries. No contradictions 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.

  Conciseness4/5

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

  The description is front-loaded with the main purpose and keeps sentences focused. It could integrate the python_path explanation more efficiently, but overall concise and well-structured.

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

  Completeness3/5

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

  Given no output schema, the description mentions returning a summary but lacks details on its structure. Edge cases like missing notebook or kernel state are not addressed. Adequate for basic understanding but not comprehensive.

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

  Parameters2/5

  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 parameters. It explains stop_on_error and python_path, but fails to describe 'name' (required) and 'timeout' (default 30). Only 2 of 4 parameters are covered.

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

  Purpose5/5

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

  The description clearly states the tool executes all code cells in order, skipping markdown and raw cells. This distinguishes it from sibling tool cell_execute (single cell) and other notebook tools.

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

  Usage Guidelines3/5

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

  The description implies usage for batch execution but does not explicitly state when to use this tool versus cell_execute. The reference to cell_execute for python_path hints at its existence but lacks direct comparison.

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

• cell_deleteA
  3.9/5.0
  Behavior3/5

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

  The description confirms the destructive nature implied by annotations ('delete'). However, it adds no extra behavioral context beyond what the annotations already provide (destructiveHint: true, idempotentHint: true). The description does not elaborate on side effects or irreversibility.

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

  Conciseness5/5

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

  The description is extremely concise: two sentences front-load the action and prerequisite. No unnecessary words or repetition.

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

  Completeness4/5

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

  Given the simple tool (two params, no output schema) and presence of annotations, the description covers the core purpose and a key prerequisite. However, it omits explanation of the 'name' parameter, slightly reducing completeness.

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

  Parameters2/5

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

  With 0% schema description coverage, the description should explain parameter meaning. It only mentions that notebook_get provides cell IDs, but does not clarify the 'name' parameter or specify that 'cell_id' is a string ID. This leaves ambiguity about required inputs.

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

  Purpose5/5

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

  The description clearly states the action ('Delete a cell'), the resource ('from a notebook'), and the method ('by its cell ID'). This verb-resource pairing distinguishes it from sibling tools like cell_add or cell_update.

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

  Usage Guidelines4/5

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

  The description provides a helpful prerequisite: 'Use notebook_get to find cell IDs.' This guides the agent on prior steps, though it does not explicitly mention when not to use this tool or compare to similar mutation tools like cell_move.

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

• cell_moveA
  3.9/5.0
  Behavior3/5

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

  Annotations already indicate non-readonly, so the description's mention of 'move' is expected. It adds the 0-indexed detail and a hint about notebook_get, but does not disclose side effects or boundary conditions.

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

  Conciseness5/5

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

  Two concise sentences with key information front-loaded, no unnecessary words.

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

  Completeness3/5

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

  Basic information is present, but missing details like error handling (out-of-range positions), behavior for same position, and validation of name/cell_id, which would improve completeness given the lack of output schema.

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

  Parameters3/5

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

  With 0% schema coverage, the description partially compensates by explaining new_position's 0-indexed nature, but does not clarify the role of name or cell_id beyond their names.

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

  Purpose5/5

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

  The description explicitly states the action (move), the resource (cell), and the target context (notebook), clearly distinguishing it from siblings like cell_add or cell_delete.

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

  Usage Guidelines4/5

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

  Provides specific guidance: new_position is 0-indexed and suggests using notebook_get to see current positions, though it does not explicitly state when not to use this tool or mention alternatives beyond notebook_get.

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

• get_notebook_directoryA
  3.9/5.0
  Behavior3/5

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

  Annotations already indicate readOnlyHint=true, so the description adds minimal behavioral context. It confirms the read-only nature but does not elaborate on possible behavior (e.g., what happens if no directory is set).

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

  Conciseness5/5

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

  The description is a single, concise sentence that conveys the tool's purpose with no unnecessary words. It is appropriately sized for a simple getter tool.

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

  Completeness3/5

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

  Given the tool has no parameters, a single-line description may suffice. However, the lack of an output schema means the description does not clarify what the return value is (e.g., a string path), which could limit completeness for an agent.

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

  Parameters4/5

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

  The input schema has no parameters, so schema coverage is effectively 100%. The description adds no parameter information, but none is needed. Baseline score of 4 is appropriate.

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

  Purpose5/5

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

  The description clearly states the verb ('Get') and the resource ('current working directory for notebook operations'). It implicitly distinguishes from the sibling 'set_notebook_directory' by focusing on retrieval rather than modification.

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

  Usage Guidelines3/5

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

  The description does not provide explicit guidance on when to use this tool versus alternatives. While the purpose is clear, the lack of mention of the sibling 'set_notebook_directory' or any context about when not to use it reduces the score.

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

• cell_updateA
  4/5.0
  Behavior4/5

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

  The description discloses a key behavioral trait: updating a code cell clears its outputs and execution count. This adds transparency beyond the annotations, which are neutral. However, it does not mention other potential side effects or permanence.

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

  Conciseness5/5

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

  The description is extremely concise: three sentences that efficiently convey the purpose, a behavioral nuance, and a practical usage hint. No unnecessary words.

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

  Completeness3/5

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

  The description covers the core purpose and a key side effect but omits explanation of the 'name' parameter and does not indicate the return value or response format. Since there is no output schema, the agent would benefit from knowing what to expect after invocation.

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

  Parameters2/5

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

  With 0% schema coverage, the description must explain all parameters. It only indirectly addresses 'cell_id' via the usage tip and mentions 'source' as content. The 'name' parameter is not explained, leaving ambiguity. This is insufficient for a 3-parameter required tool.

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

  Purpose5/5

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

  The description clearly states the tool updates the source content of a cell, distinguishing it from siblings like cell_add or cell_execute. It also advises using notebook_get for cell IDs, reinforcing its specific purpose.

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

  Usage Guidelines4/5

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

  The description provides a clear context (update cell source) and a useful prerequisite (find cell IDs with notebook_get). It does not explicitly contrast with alternatives like cell_add or cell_delete, but the purpose is distinct enough given the siblings list.

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

• cell_addA
  4.1/5.0
  Behavior3/5

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

  The description adds moderate value beyond annotations by stating the return value (cell ID and position) and specifying defaults. However, it does not disclose error handling, required permissions, or behavior on invalid inputs, which are important for a mutation tool.

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

  Conciseness5/5

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

  The description is short, uses bullet-like formatting for clarity, and front-loads the purpose. Every sentence is essential, with no redundancy or fluff.

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

  Completeness4/5

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

  Given the tool's simplicity (4 parameters, no output schema), the description covers purpose, parameters, and return value. It lacks information about prerequisites (e.g., notebook must exist) and error conditions, but overall it is fairly complete for an add operation.

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

  Parameters5/5

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

  With 0% schema description coverage, the description compensates fully by explaining each parameter: name format, source content, cell_type options with default, and position semantics (0 = first, -1 = append). This adds significant meaning beyond the schema's type and defaults.

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

  Purpose5/5

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

  The description clearly states the action 'Add a new cell' and the target resource 'notebook', making the purpose unambiguous. It differentiates from sibling tools like cell_delete and cell_update by focusing on addition.

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

  Usage Guidelines3/5

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

  The description implies usage for adding cells but provides no explicit guidance on when to use this tool versus alternatives, nor does it mention prerequisites or exclusion criteria. The context is implied by the tool's function.

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

• cell_executeA
  4.1/5.0
  Behavior4/5

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

  Annotations are silent; description adds critical behavior: kernel state persists between executions, outputs saved to .ipynb file, and python_path control details. 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.

  Conciseness4/5

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

  Front-loaded with action, efficient two paragraphs. Could be slightly tighter but no wasted sentences.

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

  Completeness4/5

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

  Covers key behavioral aspects (persistence, file saving, python_path). Missing output format description or error handling, but sufficient for typical usage given no output schema.

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

  Parameters3/5

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

  Schema has 0% description coverage; description explains python_path in detail and implies cell_id usage. However, name and timeout are not explained, leaving some ambiguity despite the useful python_path clarification.

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

  Purpose5/5

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

  The description clearly states 'Execute a specific code cell and return its output', specifying verb, resource, and scope. It distinguishes from siblings like cell_add and notebook_execute_all by focusing on single code cell execution with kernel state persistence.

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

  Usage Guidelines4/5

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

  It provides guidance on when to use (only code cells) and explains when python_path takes effect, but lacks explicit comparison to alternatives like notebook_execute_all or kernel_start. Includes context on when to use kernel_restart for switching Python.

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

• kernel_statusA
  4.1/5.0
  Behavior5/5

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

  Annotations provide readOnlyHint=true, and the description adds value by detailing possible status values and explaining when python_path is null. No contradictions.

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

  Conciseness5/5

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

  Two concise sentences with no fluff. The description is front-loaded with the main purpose and includes essential details.

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

  Completeness4/5

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

  Given the low complexity and presence of annotations, the description is mostly complete. It explains the returned status and python_path, though it does not detail the full output structure.

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

  Parameters2/5

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

  The single parameter 'name' is not explained in the description. With 0% schema coverage, the tool should clarify what 'name' refers to (e.g., notebook name), but it does not.

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

  Purpose5/5

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

  The description clearly states the action 'Get' and the resource 'status and Python interpreter of the kernel for a notebook.' It distinguishes from sibling tools like kernel_start or kernel_restart by focusing on status retrieval.

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

  Usage Guidelines3/5

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

  The description does not explicitly guide when to use this tool vs alternatives. It implies it's for checking status, but no exclusions or conditions are mentioned.

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

• kernel_restartA
  4.2/5.0
  Behavior4/5

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

  The description discloses that the tool clears in-memory state (aligning with destructiveHint=true) and explains the behavior when python_path differs. Annotations already provide basic hints, but the description adds valuable context beyond them.

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

  Conciseness5/5

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

  The description is well-structured, starting with the main action, then effects, then parameter details. Every sentence adds value without unnecessary verbosity.

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

  Completeness4/5

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

  The description covers the main action, effects, and python_path parameter in detail. The only gap is the missing explanation of the 'name' parameter. Overall, it is fairly complete for a tool of this complexity.

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

  Parameters3/5

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

  The description provides rich detail for python_path (three cases and implications) but does not explain the required 'name' parameter, which is critical for correct usage. Schema coverage is 0%, so the description should cover both.

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

  Purpose5/5

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

  The description clearly states the action ('Restart the kernel for a notebook') and the resource. It distinguishes from siblings like kernel_interrupt and kernel_start by explaining what is reset and what is preserved.

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

  Usage Guidelines4/5

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

  The description provides context on when to use the python_path parameter and the behavior of restart vs full replacement. However, it does not explicitly address when to use this tool over alternatives like kernel_interrupt or kernel_start.

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

• notebook_createA
  4.2/5.0
  Behavior4/5

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

  Annotations provide basic non-read-only hint, but description adds value by revealing automatic extension handling and return of name/path. However, it does not mention overwrite behavior or error conditions, which are minor omissions.

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

  Conciseness5/5

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

  The description is three concise sentences covering creation, extension behavior, and return value. No redundant words, and key information is front-loaded.

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

  Completeness4/5

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

  For a simple tool with one parameter and no output schema, the description covers purpose, parameter behavior, and return info. Minor gap: no mention of error cases or existence checks, but overall sufficient.

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

  Parameters4/5

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

  With 0% schema coverage, the description compensates by explaining the name parameter's extension handling. This adds meaning beyond the schema's bare string type. No details on validation or constraints, but adequate for a single parameter.

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

  Purpose5/5

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

  The description clearly states the verb 'Create' and the resource 'Jupyter notebook (.ipynb)'. It distinguishes from sibling tools like notebook_delete, notebook_get, etc., by specifying creation. The detail about automatic .ipynb extension addition further clarifies purpose.

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

  Usage Guidelines3/5

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

  The description implies usage for creating notebooks but does not explicitly state when to use this tool versus alternatives like notebook_as_script or notebook_execute_all. No exclusion criteria or prerequisites are mentioned.

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

• notebook_listA
  4.2/5.0
  Behavior4/5

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

  The annotation 'readOnlyHint: true' already indicates read-only behavior. The description adds that it lists notebooks in the working directory, which is consistent and provides context beyond annotations.

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

  Conciseness5/5

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

  The description is a single sentence with no superfluous words. It is front-loaded and efficiently communicates the tool's function.

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

  Completeness4/5

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

  For a simple, parameterless, read-only list tool, the description is adequate. No output schema exists, but the return value (list of notebook filenames) is implied. Could mention ordering or filtering, but not necessary given the tool's simplicity.

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

  Parameters4/5

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

  There are no parameters, and the schema has 100% coverage. The description adds no parameter info, which is appropriate given zero parameters. Baseline 4 applies.

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

  Purpose5/5

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

  The description 'List all .ipynb notebooks in the working directory' uses a specific verb ('List') and resource ('.ipynb notebooks'), clearly distinguishing it from sibling tools that create, delete, execute, or manipulate notebooks.

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

  Usage Guidelines3/5

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

  No explicit guidance on when to use this tool versus alternatives. The purpose is implied, but there is no 'when not to use' or comparison with sibling tools like 'notebook_get' or 'notebook_as_script'.

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

• remote_statusA
  4.2/5.0
  Behavior4/5

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

  Annotations already indicate readOnlyHint=true, and the description adds value by specifying that it shows connection status and URL. No contradictions 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.

  Conciseness5/5

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

  Single sentence, no unnecessary words, front-loaded information. Every word earns its place.

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

  Completeness4/5

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

  Given no output schema, the description adequately indicates what the tool returns (status and URL). It could be more specific about output format, but for a simple status check it is complete enough.

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

  Parameters4/5

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

  No parameters are defined, and schema coverage is 100%. Description does not need to explain parameters, and it adds no redundant information.

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

  Purpose5/5

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

  The description uses a specific verb ('Show') and resource ('remote Jupyter Server') and clearly indicates what information is provided (connected status and URL). It distinguishes from sibling tools that modify connections (remote_connect, remote_disconnect).

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

  Usage Guidelines3/5

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

  The description implies the tool is for checking connection status but does not explicitly state when to use it over alternatives or provide usage context. However, sibling tools suggest its complementary role.

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

• kernel_listA
  4.3/5.0
  Behavior4/5

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

  Annotations provide readOnlyHint=true, and the description adds the important scope that only kernels started during this session are listed, which is beyond the annotation alone. No contradictions.

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

  Conciseness5/5

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

  Two concise sentences, front-loaded with the action and resource, every word adds value. No wasted text.

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

  Completeness5/5

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

  For a parameterless list tool with annotations, the description is fully complete: it states the purpose, output content, and scope constraint. No output schema is needed as the description covers the return details.

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

  Parameters4/5

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

  The tool has zero parameters, so schema coverage is 100%. The description adds value by clarifying what information is returned (status and interpreter path), earning a baseline of 4.

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

  Purpose5/5

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

  The description specifies the verb 'list', the resource 'kernels', and includes output details (status, interpreter path) and the scope constraint (only kernels started in this session), clearly distinguishing it from sibling tools like kernel_status.

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

  Usage Guidelines3/5

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

  The description implies use for obtaining an overview of all session kernels, but it lacks explicit guidance on when to use this tool versus alternatives such as kernel_status or kernel_restart, relying on implicit context from sibling names.

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

• kernel_startA
  4.3/5.0
  Behavior4/5

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

  Annotations already mark destructiveHint=true, but description adds value by explaining the fresh start and the python_path restriction with remote servers, which annotations do not cover.

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

  Conciseness5/5

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

  Well-structured: main action, comparison, use cases, then parameter details. Each sentence serves a purpose with no waste.

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

  Completeness4/5

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

  Covers main action, differentiation, use cases, and a constraint. Missing explanation of the 'name' parameter, but overall adequate for a destructive tool with no output schema.

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

  Parameters2/5

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

  Schema description coverage is 0%, so description must explain parameters. It details python_path well but fails to explain the 'name' parameter, leaving a significant gap in parameter understanding.

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

  Purpose5/5

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

  The description clearly states it shuts down existing kernel and starts a fresh one. It explicitly differentiates from sibling kernel_restart by noting it always creates a new process from scratch.

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

  Usage Guidelines5/5

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

  Provides explicit when to use ('at session start', 'to guarantee a clean slate') and when not ('not supported when connected to a remote server'), with alternative suggested (use remote_connect).

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

• notebook_getA
  4.4/5.0
  Behavior4/5

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

  Annotations already declare readOnlyHint=true, and the description confirms read-only behavior. It adds what is returned (cell IDs, types, etc.), but does not mention any potential limitations or prerequisites. Still, it is consistent and adds useful detail.

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

  Conciseness5/5

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

  Two sentences, no wasted words. Front-loaded with the main action and immediately provides actionable information on how to use the output. Perfectly concise.

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

  Completeness5/5

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

  Given the tool's simplicity (one parameter, no output schema), the description covers purpose, return contents, and collaboration with siblings. No gaps remain for an agent to understand how to use this tool correctly.

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

  Parameters2/5

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

  Input schema has 0% description coverage for the only parameter 'name'. The description does not clarify what 'name' refers to (e.g., notebook name or path). While the parameter is simple, the description should compensate but fails to do so.

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

  Purpose5/5

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

  Description clearly states 'Read a notebook and return its full structure', listing specific components (cell IDs, types, source, execution counts, outputs). This verb+resource combination distinguishes it from siblings like notebook_list or cell_add.

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

  Usage Guidelines5/5

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

  Explicitly states when to use (to read a notebook and get cell details) and instructs to use returned cell IDs with cell_update, cell_delete, cell_move, cell_execute for modifications. Provides clear context and alternatives.

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

• notebook_as_scriptA
  4.6/5.0
  Behavior5/5

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

  Annotations already declare readOnlyHint=true. The description adds detailed behavior: each cell preceded by # %%, markdown cells prefixed with '# ', raw cells skipped, and no file written. Fully discloses behavior beyond annotations without contradiction.

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

  Conciseness4/5

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

  The description is reasonably concise and well-structured with bullet points, though slightly verbose in explaining the marker format. It front-loads the core purpose and uses clear sections.

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

  Completeness5/5

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

  Given the simple tool (2 parameters, no output schema), the description fully covers all relevant aspects: input parameters, behavior for each cell type, return format, and side-effect statement. No gaps remain.

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

  Parameters4/5

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

  With 0% schema description coverage, the description compensates by explaining include_markdown's effect. However, the 'name' parameter is not explicitly defined beyond context; the description could be clearer about its role (e.g., notebook identifier). Good but not perfect.

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

  Purpose5/5

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

  The description clearly states the tool returns the entire notebook as a Python script string, detailing the format with # %% markers and handling of code, markdown, and raw cells. This distinct purpose differentiates it from siblings like notebook_get or cell_execute.

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

  Usage Guidelines4/5

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

  The description explains when to use the tool for analysis, diffing, or reasoning, and that no file is written. It implicitly contrasts with execution or other retrieval tools, but lacks explicit 'do not use if' statements.

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

• remote_connectA
  4.6/5.0
  Behavior4/5

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

  Annotations indicate non-read-only, non-destructive, non-idempotent. The description adds context that notebooks remain local and existing remote kernels are killed, which is valuable behavioral insight beyond the annotations.

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

  Conciseness5/5

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

  The description is succinct with three sentences and two parameter lines, front-loading the purpose and avoiding unnecessary words.

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

  Completeness5/5

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

  The description covers the tool's effect, parameter formats, and a caution about shutting down existing kernels, making it complete for a connection tool without an output schema.

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

  Parameters5/5

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

  With 0% schema description coverage, the description fully compensates by explaining 'server_url' with an example and 'token' with its origin, adding essential meaning beyond the schema's title and type.

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

  Purpose5/5

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

  The description clearly states the verb 'Connect' and the resource 'remote Jupyter Server', and specifies that only kernel operations are routed remotely while notebooks stay local, distinguishing it from sibling tools like 'remote_disconnect' and 'kernel_start'.

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

  Usage Guidelines4/5

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

  The description explicitly states the use case 'accessing remote compute, GPUs, or data', and mentions that existing remote kernels are shut down, but does not compare to alternatives like 'kernel_start' for local kernels.

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