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

No annotations are provided, so the description carries full burden. It discloses the whitelist constraint but does not mention error handling (e.g., if app is not running) or 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 two sentences, front-loading the trigger condition and then the restriction. No unnecessary words.

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

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

Given the tool's simplicity, the description covers when to call and the key constraint. However, it is missing parameter format guidance, which would improve completeness.

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 'app_name'. The description only says '关闭某个App' without specifying the required format (e.g., display name, bundle ID). This leaves ambiguity for the agent.

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 closes a macOS App when the user requests it, and specifies the whitelist restriction. This distinguishes it from sibling tools like app_open.

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 says '当用户说关闭某个App时调用' indicating when to use. It also mentions the whitelist restriction. However, it does not discuss alternatives or when not to use.

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

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

No annotations are provided, so the description carries the full burden. It discloses the whitelist restriction, which is a key behavioral trait, but does not mention failure behavior or authorization requirements.

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 short sentences, front-loads the trigger scenario, and adds the whitelist constraint without extraneous detail.

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 one-parameter tool with no output schema, the description covers the essential context (when to call, restriction). It omits details like success/error responses, but given the tool's simplicity, it 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 0% description coverage, and the description adds no information about the 'app_name' parameter beyond what the schema's title ('App Name') implies. No format, examples, or constraints are provided.

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 opens macOS apps from a whitelist when the user says 'open a certain app'. It distinguishes from the sibling tool 'app_close' by specifying the opening action.

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 when to call (user request to open an app) and includes a constraint (only whitelisted apps). It does not explicitly list when not to use or alternative tools, 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.

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

No annotations are provided, and the description does not disclose behavioral traits such as whether the tool is destructive, what exactly it modifies, or any authorization requirements. The phrase 'clean up' implies mutation but is not explicit.

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

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

The description is a single, front-loaded sentence with no wasted words. Every word contributes to stating the tool's purpose.

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 has no parameters, no output schema, and low complexity, the description is adequate. However, it could be more complete by explaining what 'session registrations' are or what conditions trigger the cleanup.

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, and the schema description coverage is 100% (trivially). With no parameters to describe, the baseline score of 4 applies; the description does not need to add parameter information.

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 verb '清理' (clean up) and the specific resource '已经不存在的 Claude Code/Codex 可见会话登记' (session registrations that no longer exist). This distinguishes it from sibling tools like cc_list_sessions or cc_start_session, which serve different purposes.

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 does not mention prerequisites, side effects, or conditions under which the cleanup is 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 must carry the full burden. It states the action (close) which implies destruction, but does not mention side effects, permissions, or error states. It is minimally transparent.

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, front-loaded with the trigger condition. It is efficient but could include parameter guidance without bloat. Still achieves good density.

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 one-parameter tool, the description should cover parameter values and expected behavior. It lacks this, and with no output schema, the agent is left without return info or error cases. Incomplete for effective use.

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 0% and the description does not explain the 'terminal' parameter at all. The default value 'Terminal' is in the schema but not described; allowed values or formats are omitted. The description fails to add meaning beyond the 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 clearly states the tool closes the foreground Terminal/iTerm window, with a specific verb and resource. It distinguishes well from sibling tools that manage sessions or other apps.

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 an explicit trigger ('当用户说...') but does not mention when not to use the tool, nor any alternatives. No guidance on prerequisites or exclusions.

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 full burden of behavioral transparency. It only states that the tool creates a task and does not execute commands, but lacks details about side effects, persistence, error handling, or return values. This is insufficient for a task creation 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?

The description is a single, focused sentence that conveys purpose and limitation with no wasted words. It is front-loaded and earns every word.

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 4 parameters, no output schema, and no annotations, the description is too minimal. It fails to provide sufficient context for correct usage, such as parameter details or expected outcomes, making it incomplete for an agent to reliably invoke the tool.

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

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

Schema description coverage is 0% and the description adds no meaning to any of the 4 parameters. It does not explain 'priority' values, 'project_path' usage, or 'instruction' format. The agent would have no guidance on how to fill these fields 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?

The description clearly states the tool's purpose: creating a to-do task when the user says 'let cc/Codex/Claude Code do...'. It specifies the verb (create) and resource (task), and distinguishes itself by explicitly saying it does not execute commands, which sets it apart from sibling tools that execute commands.

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 clear when-to-use guidance: when the user invokes cc/Codex/Claude Code to do something. It also states what not to do (do not execute commands). However, it does not explicitly mention alternatives among sibling tools, though the context implies differentiation.

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 provided, so description bears full burden. It discloses that the session must be 'visible' to be focused, which is a useful constraint. However, it does not describe behavior if session ID is invalid or not visible.

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?

Single sentence with no redundancy. Could be slightly expanded to include parameter guidance, but it is efficient as is.

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 simplicity and lack of output schema, the description is adequate but incomplete. It omits how to obtain the session ID and error scenarios, which would be helpful.

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 description does not explain the session_id parameter or its source (e.g., from cc_list_sessions). With 0% schema coverage, this is a significant gap. The default value is unmentioned.

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 (bring to front) and resource (specified visible session window). It distinguishes from siblings like cc_open_visible_session, which likely opens new sessions. However, it could be more explicit about differentiation.

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 like cc_open_visible_session or desktop_focus_cc. The context is implied but not explicitly 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, the description must disclose behavior. It implies read-only listing of visible sessions, which is adequate for a simple list. However, it does not explicitly confirm no side effects or required permissions.

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?

Single sentence, front-loaded with verb and resource. No extraneous words; every part is necessary.

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 parameterless list tool with no output schema, the description is fully adequate. It tells the agent exactly what the tool does and the domain of sessions covered.

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?

No parameters exist (schema coverage 100%), so baseline is 4. The description adds meaning by specifying it lists 'visible' sessions 'remembered by the current service process', clarifying the scope.

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 the exact verb 'list' and resource 'visible Claude Code/Codex sessions' from the current service. It clearly distinguishes from sibling tools that manipulate or focus sessions.

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 like cc_focus_session or cc_session_status. The description does not mention when not to use it or what context makes it 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?

With no annotations, the description carries full burden. It states that the tool defaults to starting Claude in the visible Terminal, which is a key behavioral trait. But it does not disclose other behaviors such as error handling, session management, or whether it closes existing sessions. The description is insufficient for a tool with multiple parameters and no output schema.

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, which is concise and front-loaded with the usage trigger. However, it is written in Chinese while the tool name is English, which might cause confusion. For a tool with four parameters, it is overly brief, but conciseness itself is not penalized heavily.

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 has four optional parameters, no schema descriptions, no output schema, and no annotations, the description is severely incomplete. It only covers the basic action and trigger, leaving the agent without sufficient context to use parameters or interpret 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 description adds no meaning to the four parameters (cli_args, terminal, session_id, project_path). Since schema description coverage is 0%, the description should compensate, but it does not mention any parameter. An agent has no context to set these parameters correctly.

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 opens Claude Code when the user says specific phrases like '打开 Claude Code/打开 cc'. It identifies the verb 'open' and the resource 'Claude Code'. However, it does not explicitly differentiate from sibling tools like 'app_open' or 'desktop_open_cc_project', leaving some ambiguity.

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 a trigger condition ('当用户说...时调用'), indicating when to use the tool. However, it offers no guidance on when not to use it or alternatives among the many sibling tools (e.g., cc_start_session), limiting its usefulness.

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 that the tool opens a visible window and starts Claude Code/Codex, but does not detail side effects (e.g., effect on existing sessions), authentication needs, or whether it blocks or returns immediately. Additional context about what happens to prior sessions or how the visible window behaves would improve 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 a single sentence that efficiently conveys the core purpose. It is front-loaded with the action and resource. However, it could be restructured to include brief parameter hints without losing conciseness.

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 has 5 optional parameters, no output schema, and no annotations, the description is insufficient for an agent to use it correctly. The high-level purpose is clear, but without parameter semantics, usage guidelines, or behavioral details, the agent cannot determine appropriate values or when to use it. The description needs to cover parameter roles and any prerequisites.

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 5 parameters (cli, cli_args, terminal, session_id, project_path) with no descriptions (0% schema description coverage). The tool description does not explain the meaning, purpose, or acceptable values of any parameter. For an agent to invoke this tool correctly, parameter semantics are critical, and here they are entirely missing.

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 opens a visible Terminal/iTerm window and launches Claude Code/Codex for human viewing and takeover. It directly states the verb (open, start), resource (visible terminal window, Claude Code/Codex), and the purpose (方便人工观看和接管). This differentiates it from sibling tools like cc_start_session or cc_open_claude_code, which likely have different visibility or interaction modes.

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

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

The description implies the tool is for scenarios requiring human visibility and takeover, but it does not explicitly state when to use this tool over alternatives like cc_start_session or cc_open_claude_code. No when-not-to-use or prerequisite information is provided. The context is implied but not direct.

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 exist, so the description carries full burden. It mentions default behavior (allow) and configurability but lacks detail on side effects, mutability, or error states. Minimal behavioral insight.

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, which is concise but lacks structure. It combines purpose and behavioral notes without clear separation, making it somewhat dense but not optimal.

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 four parameters, no output schema, no annotations, and zero parameter descriptions, the description is insufficient. It does not clarify how to use session_id, confirm, or allow_frontmost, 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%, yet the description adds no explanation for any of the four parameters (confirm, decision, session_id, allow_frontmost). It only hints at possible decision values (yes/no/cancel) but does not specify them in the schema or description.

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

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

The description clearly states the tool sends yes/no/cancel decisions when the CLI is waiting for confirmation. While it does not explicitly distinguish from every sibling tool, the purpose is specific and recognizable among similar cc_send_* tools.

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 the tool is used for CLI confirmation prompts, providing context but no explicit when-not-to-use or alternative tools. It does not mention any prerequisites or required conditions.

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 must fully disclose behavioral traits. It only states the action without mentioning side effects, safety, blocking behavior, or what happens if the session isn't started. This is insufficient for an agent to infer usage safely.

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, short and direct. It has no wasted words, but it is not structured with bullet points or separate sections. It is appropriately concise for the given 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?

Given the tool has 3 parameters, no output schema, and many sibling tools, the description is too minimal. It does not explain the nature of the instructions, return values, or error conditions. It is not complete enough for an agent to use effectively without additional context.

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, and the tool description does not explain any parameter semantics. For example, 'allow_frontmost' and 'session_id' are not clarified. The description adds no meaning beyond the schema field 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?

The description clearly states the tool sends natural language task instructions to a started managed CLI session. It uses a specific verb ('send') and resource ('natural language task instructions' to a 'started managed CLI session'), distinguishing it from siblings like cc_send_decision and cc_send_slash_command.

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 the tool is for sending instructions to an already started session, but lacks explicit guidance on when to use it versus alternatives like cc_start_session or cc_send_slash_command. No exclusions 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.

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

With no annotations, the description provides some behavioral context (default allowed, configurable) but omits important details such as whether the command is destructive, likely side effects, error handling, or that it operates within a session (implied by session_id parameter).

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 that efficiently conveys the core purpose and a configuration note. It is front-loaded but could benefit from a more structured format.

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 has 5 parameters, no output schema, and no annotations, the description is insufficient. It fails to explain the role of most parameters, return values, error behavior, or how the tool integrates with sessions.

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 5 parameters with 0% description coverage. The description only provides example values for the 'command' parameter (e.g., /init) but does not explain 'args', 'confirm', 'session_id', or 'allow_frontmost'. This leaves most parameters undocumented.

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 sends internal slash commands like /init, /compact, /model, distinguishing it from sibling tools like cc_send_instruction or cc_send_decision. The verb 'send' and resource 'internal commands' are specific.

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 that the tool is allowed by default but can be tightened via configuration, giving a vague usage hint. However, it lacks explicit guidance on when to use this tool versus alternatives like cc_send_instruction or cc_session_status.

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 states the tool 'only reads recent output' and lists statuses, implying read-only behavior. However, it omits details about required session existence, behavior with invalid session_id, or absence of 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 that front-loads the purpose. It is relatively concise but could be slightly more efficient by removing the colon and enumeration, though it remains clear.

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 lack of output schema and parameter descriptions, the description does not cover the return format, interpretation of 'recent output', or the effect of 'max_chars'. The session_id's 'default' is unexplained, making the tool incomplete for effective use.

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 two parameters with no descriptions, and the tool description does not explain 'max_chars' or 'session_id' at all. Since schema coverage is 0%, the description fails to add any meaning beyond the basic type and default values.

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 checks the current status of the managed CLI and lists possible statuses (waiting, error, completed, running, idle). It uses a specific verb and resource, distinguishing it from sibling tools like cc_list_sessions or cc_start_session. However, it could be more explicit about the session context.

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 such as cc_list_sessions or cc_start_session. It does not mention prerequisites or exclusions, leaving the agent to infer usage from context.

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

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

No annotations provided, so description carries full burden. Mentions 'managed' and directory constraint, but fails to disclose side effects, required permissions, or state changes. Minimal behavioral disclosure.

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

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

Single sentence, no wasted words, front-loaded with the core action. Excellent conciseness.

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?

Tool has 4 parameters and no output schema or annotations. The brief description omits parameter explanations, return value, and behavioral details, making it insufficient for an agent to use 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 has 4 parameters with 0% description coverage. Description adds no meaning to any parameter (cli, cli_args, session_id, project_path). Agents cannot infer which values to provide.

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?

Description clearly states the verb (start), resource (managed Claude Code/Codex CLI session), and adds a constraint (only in allowed project directories). However, it does not differentiate from sibling tools like cc_focus_session or cc_stop_session.

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

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

Provides a condition for usage (only in allowed project directories), but lacks explicit guidance on when to use alternatives or when not to use this tool, especially given the many sibling 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?

No annotations are provided, so the description must compensate. It only states the action but does not disclose whether stopping a session is destructive, whether it requires specific permissions, or what the impact on background processes is. The behavioral context is minimal.

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

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

The description is a single concise sentence that front-loads the main action. It is appropriately short, though it could benefit from structure like bullet points or additional context for parameters.

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 complexity of two optional parameters with no schema descriptions and no output schema, the description is incomplete. It does not explain what happens to the session state, the effect of the parameters, or the expected return, leaving significant gaps for the agent to infer.

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?

Parameter schema coverage is 0% and the description does not mention any parameters. The two parameters (session_id and allow_frontmost) have no descriptions, and the tool description adds no meaning beyond the 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 clearly states the tool stops a managed session and closes the foreground terminal window, specifying the verb and resource. However, it does not differentiate from sibling tools like cc_close_terminal or cc_cleanup_sessions, which may have overlapping functionality.

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 vs alternatives like cc_close_terminal or cc_cleanup_sessions. The description simply states what it does, without context for 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?

Annotations are absent, so the description must fully disclose behavioral traits. It mentions 'default allows all models, configurable to tighten' but does not explain side effects such as whether switching affects an active session, requires permissions, or involves any destructive actions. This is insufficient for a state-modifying 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?

The description is a single, front-loaded sentence that conveys the core purpose efficiently. However, it sacrifices parameter details and usage context, meaning the brevity comes at the cost of completeness. It is concise but not optimally structured for agent consumption.

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 that there is no output schema and the tool modifies a session's model, the description should cover behavior, prerequisites, and failure scenarios. It lacks information on what constitutes a valid model, whether the session must be active, and what happens after switching. The description is incomplete for practical use.

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%, yet the description adds no explanation for any of the four parameters (model, confirm, session_id, allow_frontmost). The agent must rely solely on parameter names and types, which is inadequate for correct invocation.

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 switches the model for a managed Claude Code/Codex session, which distinguishes it from sibling tools like cc_start_session or cc_focus_session. However, the title is null and the description is in Chinese, which may reduce clarity for non-Chinese-speaking agents, though it still provides a specific verb and resource.

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, nor does it mention prerequisites, when not to use, or any context for the operation. It only states the general action, leaving the agent to infer when it is 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?

With no annotations, the description bears full responsibility for disclosing behavior. It only mentions handing over a task but does not describe what happens afterward (e.g., execution, return value, side effects, auth requirements). This is insufficient for an agent to predict tool consequences.

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 short sentence, which is concise, but it does not earn its place by providing sufficient information. It is not verbose, but the brevity comes at the cost of completeness.

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 7 parameters, no output schema, and no annotations, the description is extremely incomplete. It omits return behavior, side effects, prerequisites, and any guidance on the many optional parameters. The tool's complexity demands a much richer description.

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 add meaning. It only implicitly covers 'text' by mentioning 'natural language task', leaving 6 other parameters (cli, terminal, session_id, project_path, open_if_needed, allow_frontmost) completely unexplained. This fails to aid the agent in parameter selection.

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 it is a voice-friendly entry point to hand a natural language task to Claude Code/Codex, which clearly indicates the action and resource. However, it does not explicitly differentiate from sibling tools like cc_send_instruction or desktop_ask_cc_project, but the purpose is still specific 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 provided on when to use this tool versus alternatives, nor are there any context or exclusion hints. The agent receives no help in deciding when to invoke 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?

No annotations exist, so the description bears the full burden. It only states 'assign tasks' without explaining side effects, such as whether a new session is created, whether it blocks, or how parameters like session_id or open_if_needed affect behavior. The description is almost entirely opaque.

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 short sentence, which is concise but severely underspecified for a tool with 7 parameters. It sacrifices necessary detail for brevity, making it inadequate for proper usage.

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 output schema, no annotations, and 0% parameter documentation, the description is far from complete. It fails to explain input semantics, expected output, or side effects, leaving a major knowledge gap for an AI agent.

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 has 0% parameter description coverage, and the description adds meaning only for the 'project' parameter (via 'by project name/alias'). The critical parameters 'text', 'cli', 'terminal', 'session_id', 'open_if_needed', and 'allow_frontmost' are entirely unexplained, leaving the agent unable to use the tool effectively.

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 assigns tasks to Claude Code/Codex by project name or alias. This distinguishes it from similar tools like desktop_ask_cc (without project scope) and desktop_open_cc_project (only opens, doesn't assign).

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. It does not mention prerequisites, contexts, or situations where another tool would be more appropriate, which is a significant gap given the many sibling 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?

No annotations are provided, so the description bears full weight. It only states the return content but does not disclose any behavioral traits such as side effects, performance characteristics, or data source. Metadata like idempotency or safety is missing.

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 extremely concise: a single sentence that is front-loaded with the key action and resource. No superfluous words.

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

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

The description is adequate for a simple parameterless tool, but it lacks explicit details about the return format (e.g., list of strings, object). Since there is no output schema, the description should clarify the structure to avoid ambiguity.

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?

There are zero parameters, and schema description coverage is 100%. The description correctly implies that no input is needed. Baseline for 0 parameters is 4, and the description adds no incorrect or missing meaning for parameters.

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: returning general desktop capability categories, with specific examples. It uses a verb ('返回') and resource ('desktop capability categories'), and it distinguishes itself from sibling tools like desktop_tool_catalog by focusing on abstract categories rather than tool listings.

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 explicit guidance on when to use this tool versus alternatives. The description does not mention any conditions, prerequisites, or comparisons to sibling tools. Usage context is only implied.

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 bears full burden. It implies a read-only, non-destructive check but does not disclose important traits such as session handling (session_id default) or any side effects. The behavior is partially clear but missing details.

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 short sentence, making it very concise. However, it is front-loaded but omits necessary details, so while concise, it sacrifices completeness.

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 has two optional parameters and no output schema, the description is insufficient. It does not explain the tool's output format, how to interpret results, or how parameters affect behavior. Sibling tools add context but are not leveraged.

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 description adds no information about the two parameters (max_chars, session_id). With 0% schema description coverage, the agent receives no guidance on their meaning or usage, making this dimension severely lacking.

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 checks what Claude Code/Codex is doing or stuck on, using a specific verb and resource. It somewhat distinguishes from sibling tools like cc_session_status by labeling itself as a voice-friendly entry, but lacks specificity on the exact output.

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

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

The description implies usage for quick voice-friendly checks but provides no explicit guidance on when to use this tool versus alternatives like cc_session_status or desktop_health_detail. No exclusions or alternatives are mentioned.

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 burden. It discloses a key behavioral trait: the output is desensitized (removes sensitive data). However, it does not mention other important traits such as read-only behavior, performance characteristics, or failure modes. For a simple no-parameter tool, this is adequate but not complete.

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

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

The description is a single, front-loaded sentence. It contains no filler and every word is informative. It is perfectly sized for the simplicity of the tool.

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

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

The tool is simple with no parameters and no output schema. The description explains the purpose and a key trait (desensitization), but does not hint at the return format or structure of the summary. For a tool that provides configuration data, additional context about the output would improve completeness.

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 and no input schema beyond an empty object. The description does not need to add parameter information. Baseline score of 4 applies since schema coverage is effectively 100% and no parameter documentation 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?

The description clearly states the tool returns a desensitized configuration summary for troubleshooting the desktop MCP environment. It uses a specific verb ('returns') and resource ('configuration summary'), distinguishing it from sibling tools like 'desktop_health_detail' or 'desktop_tool_catalog'.

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

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

The description implies usage for troubleshooting ('方便排查桌面 MCP 环境'), but provides no explicit guidance on when to use this tool versus alternatives, nor any when-not conditions. Usage context is only implicit.

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 bears full responsibility for disclosing behavioral traits. It merely says 'continue' without explaining what that entails (e.g., does it resume a paused session? does it require a running session? what are the side effects?). Critical behavioral context is missing.

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 short sentence, making it concise. However, conciseness is only valuable when it still conveys necessary information; here the brevity leads to omission of crucial details, so it is not a strength in this case.

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 complexity (3 parameters, no output schema, no annotations, numerous sibling tools), the description is grossly incomplete. It does not define what 'continue' means, how the parameters affect behavior, or how this tool fits into the workflow alongside siblings like cc_start_session, cc_stop_session, or cc_focus_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?

The description does not explain any of the three parameters (confirm, session_id, allow_frontmost). While their names and defaults provide some hint, with 0% schema description coverage the description should compensate by clarifying their roles and effects, which it fails to do.

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 specifies 'let Claude Code/Codex continue', identifying the verb (continue) and resource (Claude Code/Codex session). However, it does not clearly differentiate from sibling tools like cc_send_instruction or cc_start_session, and 'continue' is ambiguous—it could mean resume, proceed with a pending task, or something else.

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 the many related sibling tools (e.g., cc_send_instruction, desktop_focus_cc, cc_start_session). The phrase 'voice-friendly entry' hints at a voice use case but offers no when-to-use or when-not-to-use instructions.

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 fully explains the simple behavior: bringing a window to the foreground. It is clear and sufficient for the action, though it could mention edge cases like if the window does not exist.

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

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

The description is a single, front-loaded sentence that conveys the purpose without any unnecessary words. It is highly concise.

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 focus tool, the description is adequate for basic understanding, but it lacks parameter explanation and usage context. Given no output schema, it meets minimum requirements but has room for improvement.

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 single parameter session_id has 0% schema description coverage and is not explained in the tool description. The description adds no meaning to the parameter, leaving its purpose unclear.

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?

Description clearly states the tool brings the Claude Code/Codex window to the foreground. It uses a specific verb-resource structure and distinguishes from sibling tools that focus on different aspects of Claude Code.

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 explicit guidance on when to use this tool vs alternatives like cc_focus_session or desktop_ask_cc. The description only states what it does without providing context or exclusions.

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 must carry full weight. It only states a diagnostic function but does not disclose whether the tool modifies state, requires permissions, or has side effects. The description is insufficient for understanding the tool's behavioral traits.

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, concise sentence that delivers the core information without any superfluous words. It is front-loaded and 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 diagnostic tool with no output schema and no annotations, the description provides a general overview but lacks details on expected output or specific checks. It is adequate but leaves gaps for an agent needing to understand exactly what information is returned.

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 is empty. The description does not add parameter-specific information, but with zero parameters, this is not a deficiency. The baseline is 4.

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: diagnosing the desktop MCP environment, listing specific aspects like paths, CLI, terminal app, and key configurations. It distinguishes from sibling tools by focusing on health details rather than summary or other operations.

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, nor does it mention prerequisites or scenarios where it is particularly useful.

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, and the description does not disclose behavioral traits such as whether the tool is read-only, destructive, requires authentication, or has side effects. It simply says 'route', which is ambiguous.

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 short sentence, but it is under-specified and fails to convey necessary information. Conciseness is not achieved because the content is insufficiently informative.

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

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

With 3 parameters (2 required), no output schema, and no annotations, the description is severely incomplete. It lacks any information about return values, side effects, or usage examples, making it insufficient for correct invocation.

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 mentions 'category' and 'intent' as routing criteria but does not explain valid values, format, or the purpose of the 'params' object. Adds minimal meaning beyond parameter 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?

The description is vague: 'general desktop intent entry' and 'route to underlying security capabilities' do not specify a concrete action or resource. It fails to clearly communicate what the tool does, especially compared to more specific sibling tools.

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 its many siblings (e.g., desktop_ask_cc, desktop_check_cc). The description lacks any context for selection or exclusion criteria.

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, and the description does not disclose any behavioral traits such as read-only nature, permissions, or side effects. It only states the function without additional context.

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 concise sentence with no fluff, fully front-loaded with the core purpose. 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?

The tool has no output schema, so the description should explain the return structure. It only states the resource but not the format or fields returned, leaving some ambiguity.

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, and the input schema coverage is 100%. Per the guidelines, baseline score for zero parameters is 4. The description adds no parameter info, which is acceptable.

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 lists white-listed projects that can be opened by the desktop MCP. The verb 'list' and resource 'white-listed projects' are specific, and no sibling tool serves an identical purpose.

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 desktop_tool_catalog or other list tools. No context, prerequisites, or exclusions are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It only says 'open a visible window', which implies a GUI interaction, but gives no detail on permissions, prerequisites, side effects (e.g., whether existing sessions are reused), or what 'visible' means. The behavioral disclosure is minimal.

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

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

The description is a single sentence, which is concise but too brief to be informative. It lacks structure and prioritizes brevity over clarity, resulting in under-specification. Every sentence should earn its place, but this one omits critical details.

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 complexity (5 parameters, no output schema, no annotations), the description is severely incomplete. It does not address how to use the tool, what the parameters represent, or what the outcome looks like. The agent lacks the context needed to invoke 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?

Schema description coverage is 0%, and the description does not explain any of the 5 parameters (cli, cli_args, terminal, session_id, project_path). The agent has no information about what these parameters do or how to use them, making the tool nearly unusable without external knowledge.

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 the tool opens a visible Claude Code/Codex window for a project, which is a specific verb-resource pair. However, it remains vague by using 'a certain project' and does not clarify what 'Claude Code/Codex' is. It also does not distinguish from sibling tools like cc_open_visible_session or desktop_open_cc_project_named.

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

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

No explicit guidance on when to use this tool versus alternatives. The phrase 'voice-friendly entry' hints at a voice activation context but does not explain scenarios or exclude other tools. The description lacks any direct comparison or usage conditions.

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 convey behavioral traits. It mentions opening a visible window but does not explain side effects, permissions, or the role of parameters like 'cli', 'cli_args', 'terminal', and 'session_id'.

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 short sentence, which is concise but lacks structure. It does not front-load key information about parameters or usage context.

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

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

Given 5 parameters (1 required), no output schema, no annotations, and numerous sibling tools, the description is insufficient. It fails to explain the purpose of non-project parameters and how this tool fits with similar tools.

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 does not explain any parameter beyond implying 'project' is the name/alias. Other parameters (cli, cli_args, terminal, session_id) are completely undocumented.

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 opens a visible Claude Code/Codex window by project name/alias. However, it does not differentiate from the sibling tool 'desktop_open_cc_project', which may have overlapping functionality.

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 like 'desktop_open_cc_project' or 'cc_open_visible_session'. The description lacks context for decision-making.

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 must carry the full burden. It only states that it saves to Obsidian, with no details on side effects, authentication, or output. This is insufficient for safe invocation.

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 very short and front-loaded, but it omits parameter details that could be added without sacrificing conciseness. It is adequate but not optimal.

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 lack of output schema and low schema coverage, the description is incomplete. It does not explain what happens after saving, any return values, or error conditions, making it insufficient for reliable use.

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 description does not mention or explain any parameters (text, tags). With 0% schema coverage, this is a critical gap, leaving the agent to guess parameter usage.

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: a voice-friendly entry to save to Obsidian when the user says 'remember...'. It provides a specific trigger and resource, distinguishing it from general Obsidian tools. However, it is in Chinese, which may not be ideal for all agents.

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

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

The description implies usage when the user says 'remember...', but it does not explicitly state when not to use it or provide alternatives. Given sibling tools like obsidian_save_memory and obsidian_create_note, more guidance is needed.

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 exist, so the description must fully disclose behavior. It states it resolves to a safe project path but does not explain what 'safe' means, whether validation is performed, or if it has side effects. The description is minimal and lacks behavioral 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 concise sentence that delivers the core purpose without unnecessary words. It is front-loaded and immediately understandable.

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

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

The tool is simple with one parameter and no output schema, so the description could be adequate. However, it does not explain what constitutes a 'safe project path', error handling, or the return format. It covers the input types but leaves gaps in the overall understanding of the tool's behavior.

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 for the single parameter 'project'. The description adds significant meaning by specifying that it accepts project names, directory names, or whitelist paths, which clarifies acceptable inputs beyond the schema's plain string type.

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 action ('resolve') and resources ('project name, directory name, or whitelist path') and outcome ('safe project path'). It distinguishes from sibling tools like desktop_list_projects which lists projects, or desktop_open_cc_project which opens a project in Claude Code.

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 such as desktop_open_cc_project or desktop_list_projects. The description does not specify prerequisites, when not to use, or context of use.

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 burden. It states it exits and closes, implying destructive behavior, but does not disclose side effects (e.g., unsaved work, session state). No contradiction with annotations since none exist.

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?

Single sentence that is front-loaded with the purpose. Efficient but at the cost of omitting parameter details. Could be improved by adding brief parameter explanations.

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 2 parameters, no output schema, and a large set of sibling tools, the description is insufficient. It does not explain session_id (e.g., which session to stop), allow_frontmost behavior, or what happens after execution. Incomplete for safe agent invocation.

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 has 2 parameters (session_id and allow_frontmost) with 0% description coverage. The description provides no information about these parameters, leaving the agent to guess their meaning and impact. This is a critical gap.

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?

Description clearly states it exits Claude Code/Codex and closes the window. The verb '退出' (exit) and '关闭窗口' (close window) are specific. It distinguishes from siblings like cc_stop_session which stops a session but doesn't close the window. However, it could be clearer about what exactly is being closed (the application window).

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 like cc_stop_session or desktop_focus_cc. No mention of prerequisites or scenarios where this should be avoided. The context of 37 sibling tools makes this omission significant.

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 bears full responsibility for behavioral disclosure. It does not mention that the operation is read-only, requires no side effects, or any authentication needs. For a catalog tool, safety is assumed but not stated.

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 in Chinese, concise and free of fluff. It immediately communicates the tool's purpose without unnecessary details.

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 does not explain the format or content of the returned catalog (e.g., list of tool names, descriptions, or metadata). Despite no output schema, a user would benefit from knowing what the catalog contains. The context is incomplete for effective use.

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, and schema coverage is 100% (empty object). According to guidelines, baseline for 0 parameters is 4. The description does not need to add parameter details since none exist.

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 it returns a desktop MCP tool catalog to help select high-level tools. The verb 'return' and resource 'desktop MCP tool catalog' are specific. It clearly distinguishes from sibling tools that perform actions on desktop or other domains.

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 for discovering available tools before selecting one. It provides clear context but does not explicitly state when not to use or compare to alternatives. However, the purpose is well-understood given the tool name and 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, and the description only gives a minimal statement. It does not disclose key behavioral traits such as whether the daily note is created if missing, how content is appended (e.g., at the end), or any 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 concise sentence, but it sacrifices clarity and completeness. While not verbose, it fails to provide necessary details, making it inadequate.

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 lack of annotations, output schema, and parameter descriptions, the description is severely incomplete. It does not cover the tool's full behavior, parameter defaults, or integration with Obsidian's daily note system.

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%, meaning no parameter descriptions in the schema. The tool description does not explain the meaning or usage of the three parameters (date, text, folder), leaving the agent to infer from names alone.

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

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

The description states 'append content to Obsidian daily note', which clearly identifies the action and target. Among siblings, obsidian_append_note appends to a general note, so this tool is differentiated by 'daily note'. However, it could be more explicit about the daily note context.

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 vs alternatives like obsidian_append_note. The description only states what it does without any contextual or conditional advice.

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?

Description does not disclose behavioral traits beyond the basic action, such as whether it adds a newline, handles formatting, or what happens if the note does not exist. With no annotations provided, this leaves 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?

Extremely concise single sentence that front-loads the purpose. However, it lacks any structural elements like bullets or examples, and could be more informative without losing conciseness.

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 has 3 parameters and no output schema, the description is insufficient. It does not explain the return value, behavior on errors, or how the heading parameter affects the append operation.

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 0%, meaning the description adds no information about the parameters beyond their names. The description does not elaborate on the meaning of 'text', 'heading', or 'note_path', so it fails to compensate for the lack of schema documentation.

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

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

Description clearly states the tool appends content to a specified Markdown note in Obsidian vault. It uses a specific verb ('append') and resource ('note'), distinguishing it from sibling tools like obsidian_create_note or obsidian_open_note.

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 like obsidian_create_note or obsidian_append_daily_note. Does not mention prerequisites, limitations, or when not to use 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?

No annotations are present, so the description carries the full burden. It only states 'create new note' without disclosing overwrite behavior, file path conventions, or error conditions. The overwrite parameter exists but is not mentioned in the description.

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 extraneous information. It is direct and concise, earning its place without waste.

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 output schema, 0% schema coverage, and no annotations, the description is incomplete. It does not explain return values success/failure indicators, or error cases. More context is needed for a creation tool with multiple parameters.

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 3 parameters with 0% description coverage, but the description adds no meaning beyond parameter names. It does not explain that 'note_path' should be a relative path, how 'text' is used, or the effect of 'overwrite'. The description fails to compensate for the missing schema descriptions.

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 '新建 Obsidian vault 内的 Markdown 笔记' clearly indicates creating a new Markdown note in the Obsidian vault. The verb 'create' and resource 'note' are specific, and the tool is distinct from siblings like 'obsidian_append_note' and 'obsidian_open_note'.

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 usage guidelines are provided. The description does not specify when to use this tool versus alternatives like 'obsidian_append_note' or 'obsidian_open_note', nor does it mention any prerequisites or contexts.

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?

The description does not disclose any behavioral traits beyond the purpose. Since no annotations are provided, the description needs to cover aspects like whether opening a non-existent note creates it, or what happens if the note does not exist, but it does not.

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 at one sentence, but it is too minimal, lacking necessary details. It earns its place by being short but does not provide enough value.

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

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

Given the simple schema and lack of output schema, the description should explain the parameter format and the tool's effect. It fails to do so, leaving the agent with insufficient context to use 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?

The sole parameter 'note_path' has no description in the schema (0% coverage), and the description adds no semantics about path format, allowed values, or relative vs absolute paths.

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 verb 'open' and the resource 'Markdown note in Obsidian vault', distinguishing it from sibling tools like 'obsidian_create_note' or 'obsidian_search'. However, it does not specify what 'open' means in terms of output or action.

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 such as 'obsidian_create_note' or 'obsidian_append_note'. There is no mention of prerequisites or context.

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

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

With no annotations, the description carries the full burden but only says 'read'. It does not disclose whether the operation is destructive, requires permissions, or any side effects. Minimal 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 (one sentence), but it is under-specified. It achieves brevity at the cost of completeness.

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 tool with one parameter and no output schema, the description is somewhat adequate but missing key details: what are voice memories, return format, and any constraints. Incomplete for full understanding.

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 0% and the description does not explain the 'limit' parameter beyond its name. The parameter is simple but the description fails to add 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?

Description clearly states 'read recent voice memories', which is a specific verb-resource pair. It distinguishes from siblings like obsidian_save_memory or obsidian_search. However, 'voice memories' could be ambiguous.

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, no mention of alternatives or when not to use it. The description provides no context for decision-making.

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 burden for behavioral disclosure. It states the tool saves a voice memory but does not mention idempotency, overwrite behavior, storage details, or any side effects. This is insufficient for a write 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 a single, front-loaded sentence that immediately conveys the trigger and action. It is concise with no fluff, though it sacrifices necessary 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?

With 2 parameters, no output schema, no annotations, and 0% schema coverage, the description is critically incomplete. It fails to explain expected input format, return behavior, error handling, or storage semantics, leaving the agent without essential context.

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 does not explain the parameters ('text' and 'tags'). The default value for 'tags' is given in the schema but its purpose is not clarified. The description adds no meaning beyond the 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 specifies when to call ('当用户说记一下/保存想法/写到 Obsidian时调用') and what it does ('保存一条语音记忆'). It clearly indicates the verb (save) and resource (voice memory), and distinguishes from sibling tools like obsidian_create_note by focusing on memory rather than general notes.

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 includes a usage trigger phrase ('当用户说...时调用'), giving explicit context for when to invoke. However, it lacks guidance on when not to use or alternatives among siblings (e.g., obsidian_create_note for structured notes).

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 provided. Description hints at returning 'a few snippets' but does not specify format, pagination, or limits beyond schema default. Minimal behavioral disclosure.

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

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

Very short and front-loaded with the key verb. However, it is arguably too terse; could include more context without losing conciseness.

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, no annotations, limited parameter info. Description fails to cover return format, error behavior, or use cases, leaving significant gaps for a search tool.

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

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

Schema coverage is 0%, but description adds no explanation for parameters 'query' or 'limit' beyond what schema provides. Agent must rely on parameter names and defaults.

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?

Description clearly states it searches Obsidian vault Markdown notes and returns snippets. Verb 'search' is specific and distinct from sibling tools like obsidian_open_note, but lacks explicit differentiation.

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 vs alternatives like obsidian_open_note or obsidian_recent_memories. Agent must infer usage from context.

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

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

No annotations are provided, so the description must carry the full burden. It only says 'do not execute' but does not disclose side effects, permissions, or return behavior. Canceling is destructive, but this is not explicitly stated.

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 very short (two sentences in Chinese). It is concise but lacks sufficient detail, bordering on under-specification.

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

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

With no annotations, no output schema, and minimal description, the tool is incomplete. The agent cannot determine prerequisites, side effects, or return values.

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%. The description does not explain what action_id is or how to obtain it, leaving the agent without necessary context.

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 ('cancel') and the resource ('pending confirmed action'). It differentiates from sibling tools like pending_action_confirm, pending_action_create, and pending_action_list.

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. No mention of prerequisites or context.

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

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

With no annotations provided, the description must convey behavioral traits. It indicates a write operation (confirm and execute) but omits details on side effects, reversibility, or required user interaction.

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 concise sentence, but it is overly brief at the expense of missing critical information. It could be restructured to include parameter semantics or usage context without becoming verbose.

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 simplicity of the tool (one required parameter, no output schema), the description should provide more context about how to use it and what happens after execution. The current text is insufficient for confident tool selection and invocation.

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 only parameter 'action_id' lacks a description in the schema, and the tool description does not mention it. This leaves the agent without guidance on how to populate this required parameter.

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 verb (confirm and execute) and resource (pending action). It distinguishes from siblings like pending_action_cancel and pending_action_list. However, it does not elaborate on what constitutes a pending action.

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, prerequisites, or alternatives. The description only states what it does, not the context of when it is 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?

Discloses that the action is not immediately executed and requires whitelisted types, which informs safety. However, does not mention error handling for invalid types or state changes.

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?

Single sentence conveys core purpose and constraints. Effective but could be slightly more structured.

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 and 0% schema coverage, the description partially compensates but lacks parameter details and explanation of what 'pending action' means in practice.

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 has 0% description coverage; the description only hints at action_type constraints. No explanation of title or params fields.

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 creates a pending action, specifies constraints (whitelisted action types) and behavior (no immediate execution). This distinguishes it from siblings like confirmed or canceled actions.

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 for creating actions without immediate execution, but does not explicitly contrast with alternatives like pending_action_confirm or pending_action_cancel.

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 must fully disclose behavior. It explains the effect of the status parameter (empty means list all), but does not mention side effects, permissions, or output format. This is minimal but not misleading.

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 conveys the core purpose and a key behavioral detail. Every word is necessary, and the description is front-loaded.

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

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

The tool has no output schema, so the agent relies on the description for return expectations. The description does not mention what the response contains, leaving a gap. However, for a simple list tool, the basic purpose is clear.

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

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

The input schema provides only a type and default for the status parameter. The description adds critical meaning: that an empty value lists all actions, which is not evident from the schema alone. For a single parameter, this adds significant 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?

The description states the tool lists pending confirmation actions and explains the behavior when status is empty, clearly identifying the resource and action. It distinguishes from sibling tools like pending_action_cancel and pending_action_confirm.

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. Sibling tools exist for canceling, confirming, and creating pending actions, but the description does not help the agent decide which tool to invoke.

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?

The description mentions a whitelist constraint ('在白名单项目内'), which is a key behavioral trait. However, with no annotations provided, it fails to disclose other important aspects like side effects (e.g., file creation), permissions required, or error behavior. The agent lacks sufficient transparency to assess safety and impact.

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, which is concise but severely under-specified for a tool with 5 parameters and no schema descriptions. It does not earn its place because it leaves too many gaps that require additional explanation.

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 has 5 parameters, no annotations, no output schema, and no parameter descriptions, the description is far from complete. It omits crucial information about parameter usage, default behaviors, and expected outcomes, making it inadequate for an agent to invoke 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 input schema has 5 parameters with 0% description coverage, and the tool description adds no explanation for any parameter. Critical fields like 'scheme', 'destination', and 'project_path' remain ambiguous. The description fails to compensate for the schema's lack of documentation.

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

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

The description clearly states the tool executes 'xcodebuild build' and restricts operation to whitelisted projects. It distinguishes from sibling tools like xcode_test and xcode_clean. However, it does not mention key details like the project or scheme being built, leaving some ambiguity about the exact resource.

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 vs alternatives such as xcode_test or xcode_clean. The description lacks explicit context for when it is appropriate or not, relying solely on inference from the tool name.

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 burden. It notes the tool executes a clean operation, which is destructive, but fails to describe specific effects (e.g., removing build artifacts) or any prerequisites. No mention of side effects or limitations.

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 very short (one sentence) and does not waste words, but it lacks necessary details. It is concise but at the expense of clarity and completeness.

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

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

With five undocumented parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain what 'whitelisted' means, the role of each parameter, or what the output looks like. The tool's behavior is poorly specified.

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 the five parameters (scheme, xcode_path, destination, project_path, configuration). The agent gets no guidance on how to use these parameters.

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 executes 'xcodebuild clean' within whitelisted projects, using a specific verb and resource. It distinguishes from sibling tools like xcode_build and xcode_test.

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 'whitelisted projects' implying a constraint, but provides no explicit guidance on when to use this tool versus siblings like xcode_build or xcode_test. No context for prerequisites or alternatives.

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, and the description does not disclose behavioral traits beyond reading errors. It does not indicate whether the tool is read-only, has side effects, or depends on a prior xcodebuild. The agent lacks information about potential state changes or required conditions.

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 concise sentence in Chinese, which is appropriate for a simple tool. However, it omits necessary details like parameter semantics, making it too terse. It earns its place but sacrifices completeness.

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 simplicity (1 parameter, no output schema), the description should still cover parameter meaning and usage context. The lack of annotations and parameter explanation leaves significant gaps. An agent would struggle to use the tool correctly without additional knowledge.

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 one parameter (limit) with default 20, but the description provides no explanation of this parameter. With 0% schema description coverage, the description should clarify what 'limit' controls (e.g., number of errors to retrieve). The agent cannot infer its meaning from the description alone.

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

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

The description states it reads error clues from the last xcodebuild output, using a specific verb and resource. It distinguishes from sibling tools like xcode_build and xcode_test by focusing on error retrieval. However, the phrase '错误线索' (error clues) is somewhat vague, and the description is in Chinese, which may reduce clarity for non-Chinese speaking agents.

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 such as xcode_build or xcode_test. There is no indication of prerequisites, expected state (e.g., after a build), or when not to use it. The description purely states functionality without usage context.

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

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

No annotations are provided, and the description only says 'open', omitting details about whether it launches Xcode, what happens if the project is not whitelisted, or 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?

A single, focused sentence with no unnecessary words; it is appropriately sized and immediately conveys the core action.

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?

Missing details on return values, error handling, and system effects; for a tool that opens a project, more context about success/failure and behaviors beyond the whitelist constraint 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?

Schema coverage is 0% and the description does not explain the two parameters (xcode_path, project_path), leaving their meaning and defaults unclear.

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 opens .xcodeproj or .xcworkspace files within whitelisted projects, with a specific verb and resource, distinguishing it from sibling tools like app_open or xcode_build.

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 mention of 'whitelisted projects' implies a prerequisite, but no explicit guidance on when to use this vs. alternatives, or when not to use 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?

No annotations are provided, and the description only states the action 'execute xcodebuild test'. It does not disclose potential side effects, required permissions, or what happens if the project is not in the whitelist.

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, which is concise but under-specified. It lacks essential details, making it insufficiently informative.

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 5 parameters with no schema descriptions, no output schema, and no annotations, the description is critically incomplete. It fails to explain return values, whitelist behavior, or parameter usage.

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?

All 5 parameters have no descriptions in the schema (0% coverage), and the description adds no meaning to the parameters. The agent has no guidance on what values to provide for scheme, xcode_path, destination, project_path, or configuration.

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 executes xcodebuild test on whitelist projects, distinguishing it from sibling tools like xcode_build. However, the term 'whitelist projects' is undefined, and the Chinese language may reduce clarity for some agents.

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 like xcode_build, nor any prerequisites or constraints mentioned (e.g., project must be in whitelist).

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