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

With no annotations, the description must carry the full burden of safety and side-effect disclosure. It describes what the tool provides (overview, metrics, recommendations) and the lookup priority, but never states whether it is read-only, its return format, or any limitations. This is adequate but not comprehensive.

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 well-organized with clear sections and bullet points. It is slightly repetitive with 'RECOMMENDED' appearing both at the beginning and end, but every section earns its place and the content 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 description is fairly complete for a read-oriented analysis tool with no output schema. It explains what it provides and when to use it, but does not describe the exact response format or error behavior, which would be useful given the absence of an output schema.

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 already has 100% coverage with good descriptions for each parameter. The description adds value beyond the schema by explaining that any combination of identifiers works and specifying the priority order (project_id > workspace_path > project_name), which helps disambiguate behavior.

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 analyzes and understands project architecture, with a specific verb and resource. It lists concrete outputs (dependency analysis, complexity metrics), but does not explicitly differentiate from siblings like get_architecture_recommendation or validate_code_structure.

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?

A dedicated 'WHEN TO USE' section provides five clear scenarios, such as onboarding or before significant changes. It does not mention when not to use it or point to alternative tools, so it falls short of a 5.

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?

There are no annotations, so the description carries the full burden of disclosing behavior. It only states the action without mentioning side effects, permission requirements, idempotency, or what happens to the task's previous assignee, leaving the agent uninformed about 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 single sentence is concise and front-loaded, containing no unnecessary words. However, it is minimal to the point of under-specification, but the conciseness itself is appropriate for the tool's apparent simplicity.

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 or output schema, the description should explain return values and side effects, but it does neither. The tool is a mutation with four parameters, and the description leaves the agent without enough context to use it safely or effectively.

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

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

The input schema covers all parameters with descriptions, so the baseline is 3. The description adds no additional meaning beyond what the schema already provides, but the parameters are self-explanatory and the schema is sufficient.

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 'Assign a task to an agent' clearly states the action (assign), object (task), and recipient (agent), making it specific and distinguishable from related sibling tools like create_task and update_task_status.

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

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

No guidance is provided on when to use this tool versus alternatives, such as whether the agent must belong to the project or if it should be used before updating task status. There are no exclusions, prerequisites, or contextual hints.

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 must carry the full burden of explaining side effects and behavioral implications. It only states 'Broadcast a message to all agents' without disclosing whether messages are persisted, notifications triggered, or permission 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 only two sentences, but the second sentence is a near-verbatim paraphrase of the first ('Broadcast a message to all agents' vs 'Send a message to all agents working on the project'). It adds no new information and should be removed for true 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?

For a relatively simple messaging tool with fully documented schema, the description is adequate but thin. It lacks usage differentiation, behavioral caveats, and any context about message_type variations, making it minimally complete rather than thorough.

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

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

Schema description coverage is 100%, so all parameters have basic descriptions in the schema. The tool description adds no additional parameter-level semantics, but the schema alone is adequate for understanding the inputs.

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

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

The description uses a specific verb 'Broadcast' and clearly identifies the resource: 'a message to all agents in a project.' This distinguishes it from sibling tools like send_message, which implies a single recipient. The second sentence is redundant but does not harm clarity.

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 send_message. There are no exclusions, prerequisites, or examples of appropriate scenarios. The description merely states what it does, not when to choose 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 does not disclose side effects, reversibility, permission requirements, or return behavior. It only states the intended action, offering no additional behavioral 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 very concise (five words) and front-loaded, but it is under-specified given the tool has 4 parameters and no additional context. It avoids verbosity but misses opportunities to add useful structural 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?

With no output schema and no annotations, the description must explain what happens on completion, whether notes are stored, and any state changes. The five-word description does none of this, making it inadequate for a tool with this complexity.

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 descriptions for all four parameters, achieving 100% coverage. The description adds no additional meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description 'Mark a task as completed' clearly states the action (mark) and the resource (task) with the target state. However, it does not differentiate from the sibling tool 'update_task_status', which may serve a similar purpose, so it lacks sibling distinction.

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 'update_task_status' or 'delete_task'. It does not mention prerequisites, exclusions, or typical use cases.

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 disclose behavioral traits itself. It states the tool creates a project and is a prerequisite, but it does not mention side effects such as whether it overwrites existing projects, what happens on duplicate names, required permissions, or the response format. This is a significant gap for a mutation tool.

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

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

The description is well-structured with bold headings, bullet points, and a numbered workflow, making it easy to scan. However, there is slight redundancy: 'MANDATORY STEP 1' and 'CRITICAL: You MUST call this tool FIRST' convey the same urgency, and some phrases repeat.

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 output schema and no annotations, the description should explain what the tool returns or how to interpret success, but it does not. It does provide rich workflow context and usage triggers, which helps, but it lacks details on return values, error handling, and prerequisites (e.g., whether workspace_path must exist).

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 five parameters have descriptions in the input schema (100% coverage), so the baseline is 3. The description does not add any parameter-specific details beyond the schema; it only mentions the tool name and general purpose.

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

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

The description uses a specific verb and resource: 'Create a new project in the memory system' and 'establishes the project in CoordMCP for tracking decisions, changes, and context.' It clearly distinguishes from sibling read tools like get_project or list_projects by emphasizing creation.

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 'WHEN TO USE' section lists concrete triggers (e.g., 'Starting ANY new project or application', 'User says Create a todo app...') and the workflow explicitly says to call this tool first. However, it does not mention when NOT to use it or alternatives, only implicit differentiation from read 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 carries the full burden. It adds useful behavioral context by mentioning that tasks can be assigned, have dependencies, and form a tree structure. However, it does not disclose side effects, permissions, or what the response includes, nor does it clarify behavior around project identification via the multiple possible fields.

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

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

Two sentences, front-loaded with the core verb and object, and no wasted words. Each sentence adds meaningful information without redundancy.

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 11 parameters and no output schema, the description is minimal. It does not explain how to choose among project_id, project_name, and workspace_path, nor does it describe return values or error behavior. While the schema fills in parameter details, the tool-level context is incomplete for a tool of this complexity.

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

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

The schema provides descriptions for all 11 parameters, so the baseline is 3. The description adds semantic value by grouping parameters into features (assigned agents, dependencies, tree structure), which helps the agent understand the intent behind those fields. This lifts it above the baseline, though it does not clarify all parameter relationships (e.g., project_id vs project_name vs workspace_path).

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

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

The description opens with a specific verb and resource ('Create a new task in a project'), which clearly distinguishes it from sibling tools like create_project, update_task_status, or delete_task. It also gives a concise summary of what the tool accomplishes.

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

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

It provides a clear use case ('Use this to track work that needs to be done') and mentions key features (assignment, dependencies, tree) that imply when this tool is relevant. However, it does not explicitly name alternatives or state when not to use it, so it falls short of the highest score.

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

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

With no annotations, the description carries the burden. It does disclose the important behavioral trait of being a soft delete, but it does not explain consequences such as whether the task remains visible, whether it can be restored, or any permission requirements. This is helpful but incomplete.

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 immediately conveys the operation and its soft-delete nature. There is no wasted text or unnecessary 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?

Given the low complexity of the tool (simple parameters, full schema coverage, no output schema), the description is minimally viable. However, it does not mention the return value or what happens after deletion, which would be useful given the absence of an output schema.

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 already describes all four parameters with 100% coverage, so the baseline is 3. The description adds no additional meaning about parameter usage or relationships beyond what the schema provides.

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 ('Delete') and the resource ('a task'), and explicitly qualifies it as a 'soft delete', which distinguishes it from task update or completion tools. This is a specific and unambiguous purpose statement.

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 update_task_status or complete_task. The description implies use when deletion is desired but does not explain how soft deletion differs from status changes or when it should be preferred.

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 disclose behavioral traits on its own. It explains the search order ('first checks for an exact match, then searches up to 3 parent directories') and implies a read-only lookup, but it omits important details such as what happens when no match is found, the exact return format, and any potential side effects. This is adequate but not comprehensive.

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 well-organized with clear section headers (ESSENTIAL FOR, WHEN TO USE, WORKFLOW) and bullet points, making it scannable. The content is relevant, though the WORKFLOW section could be considered slightly extraneous for describing this specific tool. Overall, it is concise and front-loaded with the core 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?

The tool has no output schema or annotations, so the description should explain return behavior and error cases. It covers usage context and workflow but does not describe what the tool returns (e.g., project details or an ID) or how it handles a missing project. This leaves gaps for a tool at this complexity level.

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

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

Schema description coverage is 100%, providing baseline 3. The description adds meaning by explaining the search algorithm ('exact match', 'parent directories'), which enriches the understanding of the 'path' and 'max_parent_levels' parameters beyond their schema definitions. This additional context justifies a score of 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: 'Discover a CoordMCP project by searching from a directory path.' It specifies the verb ('discover'), resource ('CoordMCP project'), and the search mechanism (directory path, exact match, parent search). This distinguishes it from sibling tools like get_project_info (which retrieves project details) and create_project.

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 dedicated 'WHEN TO USE' section with concrete scenarios, such as 'Starting work in a project directory' and 'First step when joining an existing project.' It also provides a workflow that positions this tool as the initial step in a multi-tool process. However, it does not explicitly state when NOT to use the tool or name alternatives, which keeps it at a 4 rather than a 5.

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

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

No annotations are provided, so the description carries the burden. It clearly discloses the main side effects: releasing file locks, logging session end, and clearing context. It could mention edge cases like errors or idempotency, but the listed effects are sufficient for an agent to understand the tool's 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 well-structured with clear sections and front-loaded purpose. However, some redundancy exists—'End your current work context and session' and 'Clear your current context' repeat similar ideas, and the workflow repeats information from the best practice section.

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

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

Despite having no output schema, the description fully covers when to use the tool, what it does, its side effects, and the recommended workflow. For a single-parameter session-close tool, this is complete and actionable.

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 already provides 100% coverage for the single required parameter (agent_id) with a clear description. The tool description does not add additional parameter semantics, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb and resource: 'End your current work context and session.' It clearly distinguishes this from related session tools like start_context and switch_context by framing it as the terminal workflow step.

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 'WHEN TO USE' section lists explicit scenarios, and the 'WORKFLOW' section gives a clear ordered sequence: log_change(), unlock_files(), then end_context(). This is excellent guidance on when and how to use the tool versus 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, so the description must carry the full burden. It explains that the tool shows currently working agents with optional project filtering, but does not define 'active', mention the return format, or note potential side effects. This is adequate but not rich.

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 well-structured with clear sections and bullet points, making it scannable. However, it is somewhat repetitive, with 'ESSENTIAL FOR' and 'WHEN TO USE' covering overlapping territory, so it is not maximally 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 tool with three optional parameters and no output schema, the description provides adequate context about purpose, usage, and filtering. It does not explain the return value structure, but this is not critical given the tool's simplicity and the absence of an output schema.

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

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

Schema coverage is 100% with each parameter described. The description adds that filtering is by project, but does not clarify the differences between project_id, project_name, and workspace_path. Baseline of 3 applies since the schema already documents all 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 retrieves information about active agents, with a specific verb and resource. However, it does not explicitly differentiate from sibling tools like get_agents_list or get_agents_in_project, so it misses the highest score for sibling distinction.

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 'WHEN TO USE' section provides concrete scenarios and context for using the tool, such as checking who's working on a project. It does not mention when not to use it or alternatives, so it lacks explicit 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 carries the full burden. It discloses that the tool retrieves current context and session info, including locked files and prior session state. However, it does not address edge cases such as missing context, invalid agent_id, or any potential side effects. The read-only nature is implied by 'Retrieve' but 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 well-structured with a main sentence and a bulleted WHEN TO USE section. Each bullet adds a specific scenario, though the RECOMMENDED paragraph partially duplicates the bullets. It's concise and 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?

For a tool with one parameter and no output schema, the description covers the key use cases and recommended timing. It would benefit from noting what happens when no active context exists, but otherwise it's sufficient for an agent to understand when and why to call it.

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

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

The schema already describes the sole parameter 'agent_id' as 'Your agent_id from register_agent() (required)' (100% coverage). The description adds no additional parameter semantics, so baseline 3 is appropriate.

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

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

The description clearly identifies the tool's function: 'Retrieve your current work context and session information.' It uses a specific verb and resource. While it doesn't explicitly contrast sibling tools, the WHEN TO USE section implies its scope (active context, locked files, previous sessions), which helps differentiate it from history/log 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 provides an explicit 'WHEN TO USE' list with concrete scenarios (start of conversation, verify objective, see locked files, resume after interruption). It also includes a recommendation to call at the beginning of each conversation. However, it does not mention when not to use or name alternative 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 disclose behavior. The use of 'Retrieve' implies a read-only operation, and the mention of 'identity and permissions' hints at the data scope. However, it does not explicitly state that the operation is non-destructive, nor does it describe error handling, authorization requirements, 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 front-loaded with a clear one-sentence purpose, followed by a focused WHEN TO USE list. Each bullet is concise and relevant, with no filler or redundant content.

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 a single parameter and no output schema, but the description does not specify what fields constitute 'detailed profile information' or the return shape. The scenarios are helpful for context, but the absence of return details leaves a gap given no output schema exists.

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 already fully documents agent_id with 100% coverage, including the source from register_agent(). The description adds no meaningful parameter-specific details beyond the schema, so it meets the baseline for schema-covered 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 uses the specific verb 'Retrieve' with the resource 'detailed profile information about a specific agent', which clearly states the tool's function. It distinguishes from sibling list tools like get_agents_list by emphasizing 'specific agent'.

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 WHEN TO USE section explicitly lists four appropriate scenarios, such as checking registration details, understanding another agent's work, verifying identity and permissions, and coordinating between agents. However, it does not mention alternatives or when not to use, so it provides clear context but no exclusions.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It adds useful information about flexible lookup and the identifier priority (project_id > workspace_path > project_name). However, it does not state what happens if no identifiers are supplied, how 'active' is defined, or the exact return format, leaving some ambiguity for a tool that relies entirely on optional parameters.

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 well-structured with a clear summary, priority rule, and a bulleted 'WHEN TO USE' section. It is moderately sized but every section contributes to understanding the tool's purpose and usage without redundancy.

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

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

Given the simple read-only nature and three optional parameters, the description covers the main usage intent, resolution priority, and practical scenarios. It lacks details on edge cases (e.g., no parameters, no matching project) and return value format, but since no output schema exists, these omissions are noticeable yet not critical for a tool of this simplicity.

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

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

Schema coverage is 100%, with each parameter already described. The description adds meaningful value by explaining that parameters can be combined freely and establishing the priority order for resolution, which goes beyond the individual field 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 clearly states the tool's function: 'Retrieve all agents currently active in a specific project.' It specifies a concrete verb ('retrieve'), a resource ('agents'), and a scope ('in a specific project'), which distinguishes it from siblings like get_active_agents or get_agents_list that may operate globally or in a different 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 'WHEN TO USE' section provides clear scenarios: checking who is working on a project, coordinating multi-agent work, etc. It does not explicitly name alternative tools or provide exclusions, but the context is unambiguous and helps the agent decide when this tool is appropriate versus broader agent-listing tools.

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

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

With no annotations provided, the description bears the full burden of behavioral disclosure. It implies read-only via 'Retrieve' and describes the output (list of agents and status), but it does not explicitly confirm safety or side-effect-free behavior. For a simple read tool this is adequate but not exceptional.

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 front-loaded with the core purpose, followed by a 'WHEN TO USE' list that adds practical guidance. It is well-organized and avoids unnecessary fluff, though some bullets in the list are slightly redundant (e.g., 'see who else is working' and 'check if other agents are currently active').

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 (one optional param, no output schema), and the description adequately explains the return content ('list of all registered agents and their current status') and key usage contexts. It does not detail edge cases like pagination, but for this scope the description is sufficiently 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 already provides 100% coverage for the single optional `status` parameter, including default and allowed values. The description does not add new semantic information about parameters beyond what the schema states, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Retrieve a list of all registered agents and their current status.' The verb 'Retrieve' specifies the action, and the resource is explicitly 'all registered agents,' distinguishing it from sibling tools like get_agents_in_project and get_active_agents which likely filter by project or active status.

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

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

The 'WHEN TO USE' section provides concrete scenarios such as starting work, checking active agents, and coordinating multi-agent work. It lacks explicit exclusions or named alternatives (e.g., 'use get_agents_in_project for project-specific agents'), but the context is clear enough for an agent to select 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 are present, so the description carries the full burden. It discloses project lookup priority (project_id > workspace_path > project_name), the nature of the output (recommendations, design patterns, file structure, etc.), and next steps after receiving recommendations. This goes beyond the schema and provides meaningful behavioral 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 front-loaded with the key purpose but is quite lengthy, including redundant 'WHEN TO USE' and 'HIGHLY RECOMMENDED FOR' sections. While organized in clear sections, it could be condensed without losing meaning.

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

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

With no output schema and no annotations, the description compensates by listing what the tool provides (recommended approach, design patterns, implementation steps) and giving post-usage steps. It covers the essential context for using the tool, though it omits potential error scenarios.

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

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

Schema coverage is 100% with all 7 parameters described. The description adds the identifier priority order and the role of feature_description, which clarifies how parameters should be used together, exceeding the baseline.

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

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

The description clearly states 'Get expert architectural guidance before implementing major features' with a specific verb and resource. However, it doesn't explicitly differentiate from sibling tools like analyze_architecture or get_design_patterns, so it falls short of full 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?

The 'WHEN TO USE' and 'HIGHLY RECOMMENDED FOR' sections provide explicit contexts such as before major features, when unsure about approach, and for complex features. It lacks explicit when-not-to-use or named alternatives, but the guidance is clear and actionable.

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 disclose behavioral traits. It indicates the tool returns history/context entries and references 'current session' continuity, but it doesn't describe ordering, time range, or whether entries are cross-session, leaving some ambiguity.

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 brief and well-structured with a short lead-in and a bulleted 'WHEN TO USE' list. It avoids fluff, though the bullets could be seen as somewhat redundant; overall it earns its place.

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

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

For a simple fetch tool without an output schema, this description supplies the essential purpose and usage conditions. It doesn't explain return format or potential differences from sibling tools, but it's enough for basic 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 input schema covers both parameters ('agent_id' required, 'limit' default 10) with descriptions, so the schema provides the meaning. The description adds no extra parameter context beyond that.

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 'Retrieve your recent file operation history and context entries' with a clear verb and resource. It narrows the scope to 'your recent' history, making it distinct from general project history, though it doesn't explicitly distinguish from siblings like get_recent_changes.

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?

A dedicated 'WHEN TO USE' section lists concrete scenarios like reviewing recently worked files and understanding operation sequences. This provides useful context for when to invoke the tool, but no explicit alternatives or when-not-to-use guidance is given.

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

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

With no annotations provided, the description carries the full burden. It implies a read-only operation through 'Browse' and 'Returns: Dictionary', and discloses the return format. It does not mention side effects, but none are expected for a catalog lookup.

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 well-structured with headers but contains redundancy: the 'WHEN TO USE' bullets largely overlap with 'USEFUL FOR'. It could be condensed without losing meaning, but the organization aids scanning.

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

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

For a zero-parameter, simple catalog tool, the description comprehensively covers purpose, use cases, and return value. Since there is no output schema, the explicit 'Returns: Dictionary' note is valuable and 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 tool has zero parameters and schema coverage is 100%, so parameter descriptions are unnecessary. The baseline for 0-param tools is 4, and the description adds no conflicting or missing 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 'Browse the catalog of available design patterns and architectural approaches' with a specific verb and resource. It distinguishes itself from sibling tools like analyze_architecture and get_architecture_recommendation by focusing on a reference catalog rather than analysis or recommendation.

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 an explicit 'WHEN TO USE' list covering design, learning, evaluation, best practices, and architectural decisions. It lacks explicit exclusions or alternatives, but the context is clear and sufficient for this simple 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 are provided, so the description carries the full burden. It discloses key behavior: the direction parameter semantics ('dependencies': What this file imports/uses, 'dependents': What imports/uses this file) and the project lookup priority (project_id > workspace_path > project_name). It does not explicitly state that the operation is read-only, but the verb 'Analyze' implies it. Could add return format or potential errors, but it's 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?

The description is well-structured with clear sections (WHEN TO USE, IMPORTANT, DIRECTIONS) and front-loaded with a one-sentence summary. It's slightly long but each section earns its place. The 'IMPORTANT' sentence somewhat restates the value proposition, making it mildly redundant, but overall it is scannable 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?

Given there is no output schema and no annotations, the description does a good job covering the tool's purpose, usage scenarios, direction semantics, and project lookup. The only gap is not describing the exact return format (e.g., list of paths vs. graph), but the phrase 'Complete dependency graph' hints at the output. For a 5-parameter tool, this is reasonably 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?

While the input schema covers 100% of parameters, the description adds essential meaning beyond the schema. For example, the schema only lists 'dependencies', 'dependents', or 'both' for direction, but the description explains what each means in terms of downstream/upstream. It also clarifies how project_id, workspace_path, and project_name resolve, which the schema does not.

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

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

The description opens with a specific verb and resource: 'Analyze file dependencies to understand the impact of changes.' It clearly distinguishes itself from sibling tools by focusing on dependency analysis and even clarifies the direction parameter (dependencies vs. dependents vs. both), leaving no ambiguity about what the tool does.

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

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

A dedicated 'WHEN TO USE' section lists concrete scenarios such as 'Before modifying a file to see what else might break' and 'When deleting files to ensure nothing depends on them.' This explicitly tells the agent when to invoke this tool, effectively differentiating it from alternatives like analyze_architecture or get_module_info.

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

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

With no annotations, the description carries the full burden of disclosure. It clearly states the read-only nature ('Check') and provides the project resolution priority order (project_id > workspace_path > project_name). It does not describe output format in detail, but the returned information ('which files...and by whom') is adequately conveyed.

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 well-structured with a clear opening, a concise priority note, and a bulleted 'WHEN TO USE' section. It is slightly longer than necessary, but each section adds value and the text is not wasteful.

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 read-only lookup tool with three optional parameters and no output schema, the description is largely complete. It explains the core function, usage scenarios, and identifier resolution. It could be improved by explicitly noting that the tool does not modify locks or require authentication, but the overall context is sufficient for an agent to decide when and how to invoke it.

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

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

Although schema description coverage is 100%, the description adds valuable parameter semantics by explaining that any combination of identifiers can be used and by specifying the resolution priority. This goes beyond the individual field descriptions and helps the agent understand how to flexibly construct queries.

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

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

The description opens with a specific verb+resource: 'Check which files are currently locked and by whom.' This clearly distinguishes it from sibling tools like lock_files and unlock_files, which perform different actions on file locks.

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?

A dedicated 'WHEN TO USE' section lists multiple concrete scenarios, such as before planning work or when encountering conflicts. It does not explicitly mention when not to use the tool or alternatives, but the provided contexts are clear and actionable.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It mentions the scope (messages from other agents) but does not disclose whether the tool marks messages as read, ordering, pagination, or any side effects. The description does not even explicitly state it is a read-only 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 exceptionally concise, consisting of two short sentences. It front-loads the core purpose immediately and contains no filler or redundancy.

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 six parameters and no output schema, yet the description gives almost no context about return format, filtering behaviors, or default semantics. It does not explain what fields are returned, how messages are ordered, or how 'limit' and 'unread_only' interact. The description is too sparse for an effective 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?

Input schema covers 100% of parameters, so baseline is 3. The description adds no additional meaning to parameters; it only restates the concept of 'messages sent to you' which aligns with 'agent_id'. No parameter-specific insights 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's purpose: retrieving messages sent to you by other agents. It uses a specific verb ('Get'/'Retrieve') and resource ('messages'), and distinguishes itself from sibling tools like 'get_sent_messages' by specifying the direction (incoming).

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, or when not to use it. Sibling tools like 'send_message', 'get_sent_messages', and 'mark_message_read' exist but are not referenced. The context of use is implied but not explicit.

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 lookup priority (project_id > workspace_path > project_name) and mentions flexible project resolution, which adds behavioral context. However, it does not explicitly state that the operation is read-only, what 'comprehensive information' includes, or potential error conditions, leaving significant gaps for a tool with no annotations.

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

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

The description is well-structured with a lead sentence, a priority line, a WHEN TO USE list, and a USEFUL FOR line. It is not excessively long, and the sections make it easy to scan. The 'flexible project lookup' paragraph is somewhat redundant with the priority line but still adds context, so it earns a 4 rather than a 5.

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 output schema and no annotations, the description should explain what the agent will receive. It only says 'comprehensive information' and 'high-level view' without listing fields or return structure. It also does not mention prerequisites like the project existing. This is a critical gap for an agent to know what to expect from 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?

The schema already describes all parameters (100% coverage), so baseline is 3. The description adds value by explaining the interaction between identifiers, stating that any combination can be specified and that priority is project_id > workspace_path > project_name. It also clarifies that module_name is required and gives an example, going beyond the schema's individual field 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 clearly states the tool's function: 'Retrieve comprehensive information about a logical module in the project.' This is a specific verb+resource, and it differentiates from sibling tools like get_project_info by focusing on modules. The 'USEFUL FOR' line reinforces this by describing it as getting a high-level view of a component or subsystem.

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 'WHEN TO USE' section provides five concrete scenarios, such as before working on a module and checking dependencies. While it doesn't explicitly mention alternatives or when not to use, the context is clear. The tool's distinct module focus effectively implies when a project-level tool like get_project_info would be more appropriate.

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

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

No annotations are provided, so the description carries the full burden. It only states a basic read action, omitting whether it returns tasks regardless of status, whether status filters apply by default, or whether 'my' means the current agent. This creates ambiguity about behavior and could lead to incorrect expectations.

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 function with no wasted words. It is appropriately sized for a simple getter tool.

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

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

For a simple two-parameter read tool, the description gives the basic function, but gaps remain: it does not clarify the 'my' vs 'any agent' ambiguity, default status behavior, or what the output set looks like. No annotations or output schema exist, so the description should do more, but it is not severely incomplete.

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

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

Schema coverage is 100%, so parameters are documented, but the descriptions in the schema are minimal ('Agent ID', 'Filter by status'). The description adds context that agent_id is the assignee, but does not explain valid status values or default behavior. This is baseline 3, with modest added meaning.

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

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

The description clearly states the verb (Get), resource (all tasks), and qualifier (assigned to an agent), which distinguishes it from get_task (single task) and get_project_tasks (by project). However, it does not explicitly differentiate itself from those siblings or clarify whether 'my' refers to the calling agent or any specified agent.

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

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

Usage context is implied: use this tool to get tasks for a given agent. But there is no explicit guidance on when to prefer this over get_project_tasks or get_task, nor any mention of alternatives or exclusions. A more concrete 'use this when you need tasks by assignee' would be clearer.

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

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

With no annotations, the description carries the burden of disclosure. It adds useful behavioral context about resolution priority and the ability to combine identifiers, but does not mention whether the operation is read-only, what happens if no match is found, or any authorization requirements. This is a moderate gap.

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

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

The description is well-structured with clear sections (ESSENTIAL FOR, WHEN TO USE) and the priority line is front-loaded. Every sentence contributes either to understanding the purpose or usage, with no waste. It remains concise despite covering multiple scenarios.

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 lookup tool with 3 optional parameters and no output schema, the description provides sufficient context on usage and resolution behavior. It lacks details about return format and error handling, but these are less critical given the tool's simplicity and the presence of sibling tools that may handle related concerns.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining the precedence (project_id > workspace_path > project_name) and the flexibility to combine any identifiers, which are not evident from the parameter descriptions 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 clearly states a specific action ('Get project information') and the resource ('project') with multiple identifier options. It distinguishes itself from siblings by emphasizing 'flexible project lookup' with partial information, but it does not explicitly name or contrast with the sibling get_project_info, so it falls short of full sibling 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?

The 'WHEN TO USE' section provides concrete scenarios (knowing ID, name, or workspace path, and validating identifiers), and the priority order gives clear guidance on how identifiers are resolved. It does not explicitly state when not to use the tool or name alternatives, so it lacks full exclusionary guidance.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It discloses the main content of the dashboard (health score, tasks, agent activity, locks, recommendations), which helps the agent expect the response shape. However, it does not explicitly state whether it is read-only, whether it aggregates data from other tools, or any potential side effects or limitations. The listed contents add some transparency, but the absence of a 'does not modify data' statement leaves a gap for a tool with no annotation coverage.

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 well-structured and front-loaded: a clear title, a brief summary paragraph, and a bulleted WHEN TO USE list. There is minor redundancy between 'Get comprehensive project health dashboard' and 'Provides a complete overview of project status', but overall the content is efficient and scannable, earning a high score.

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 aggregates multiple data types and lacks an output schema, the description does a good job of listing the key return categories: health score, task statistics, agent activity, file locks, and recommendations. It does not cover edge cases like parameter precedence or error scenarios, but for a dashboard overview tool, the content is sufficient for an agent to anticipate the tool's value and select it appropriately.

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

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

Schema coverage is 100% (project_id, project_name, workspace_path), each with simple descriptions like 'Project ID' and 'Project name to look up'. The tool description adds no additional parameter semantics, such as whether the parameters are alternatives or how conflicts are resolved. With high schema coverage, a baseline of 3 is appropriate, as the schema already defines the parameters adequately.

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 gets a 'comprehensive project health dashboard' and enumerates specific content: health score, task statistics, agent activity, file locks, and recommendations. It distinguishes from sibling tools like get_project_info or get_project_tasks by being a composite dashboard of multiple aspects, rather than a single-purpose lookup.

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 an explicit 'WHEN TO USE' list covering four common scenarios: checking project health, seeing what needs attention, monitoring team progress, and identifying bottlenecks. It does not include when-not-to-use or alternative tool suggestions, so it stops short of a perfect score, but the guidance is clear and actionable.

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?

Since no annotations were provided, the description carries the full burden of behavioral disclosure. It adds valuable context about flexible project lookup and the priority order (project_id > workspace_path > project_name), which goes beyond the schema. It does not detail the return format or error behavior, but the read-only nature is implied by 'retrieve'.

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 well-structured and concise. It opens with the single-sentence purpose, then adds a brief note on flexible lookup, a priority line, and a focused WHEN TO USE section. Every sentence serves a clear purpose, and the structure makes it easy to scan.

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 5 parameters, no output schema, and no annotations, the description covers the main use cases, identifier resolution, and priority ordering well. It doesn't explain the response structure or edge cases (e.g., what if no decisions exist), but the purpose and usage context are strong enough for most agent scenarios.

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 covers 100% of parameters with descriptions, so baseline is 3. The description adds extra meaning by explaining that identifiers can be used in any combination and resolving priority, which enhances understanding of how the parameters relate. This is meaningful value 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 retrieves all recorded architectural and technical decisions for a project, which is a specific verb+resource combination. It distinguishes itself from sibling tools like save_decision (write) and search_decisions (search) by emphasizing 'all recorded' decisions.

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 WHEN TO USE section provides concrete scenarios (before making new decisions, understanding architectural direction, checking for contradictions) and a strong recommendation to call it at the start of work. However, it does not explicitly mention when NOT to use it or alternatives like search_decisions, so it stops short of full 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 provided, the description takes on the full burden of explaining behavior. It discloses the flexible lookup mechanism and priority order among parameters, as well as what information is returned. It does not mention error cases or side effects, but for a read-only tool the disclosed detail is sufficient and goes beyond the 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 well-structured with clear sections and front-loaded with the main purpose. It is a bit longer than strictly necessary, but each sentence contributes useful information, and the structured format aids scannability.

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

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

Given the tool's complexity and absence of annotations or output schema, the description adequately covers the lookup logic, usage timing, and the nature of returned data. It does not describe the exact return format or error handling, but the provided context is enough for an agent to decide when and how to invoke 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 input schema already covers all three parameters with descriptions, so the baseline is 3. The description adds value by explaining the combination semantics and the priority order (project_id > workspace_path > project_name), which is not explicit in the schema itself.

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 with a specific verb ('Get') and resource ('comprehensive information about a project'). It distinguishes itself from sibling tools by listing the range of data retrieved (metadata, tech stack, decisions, file dependencies, change history), setting it apart from the more specific getters like get_project_tasks or get_tech_stack.

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 'WHEN TO USE' section provides concrete contexts for using the tool, such as before starting work or resuming a project. However, it does not explicitly mention when not to use it or cite alternative tools for narrower queries, so it stops short of a perfect score.

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 content returned (project info, recent activity, active agents, key decisions, personalized context) but does not explicitly state that the operation is read-only, mention prerequisites (e.g., active registration), or address potential side effects. The name 'get' implies read, but the absence of explicit safety statements keeps it from achieving a higher score.

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 and well-structured. It opens with a clear purpose statement, follows with a one-sentence summary of the return content, and ends with a bulleted 'WHEN TO USE' list. Every sentence earns its place with no redundant or vague wording.

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

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

Given the tool's complexity (returns multiple categories of context) and the absence of an output schema, the description provides a solid high-level overview of what to expect. However, it does not detail the exact structure of the response, potential errors, or any dependencies between parameters. Still, it covers the key content areas and use cases adequately for an agent to decide whether to invoke it.

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

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

Schema description coverage is 100%, so the input schema already fully documents both parameters (agent_id and project_id). The description adds no additional semantic detail about the parameters beyond what the schema provides, such as formats, defaults, or constraints. Baseline of 3 is appropriate when schema does the heavy lifting.

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: 'Get comprehensive onboarding context when entering a project.' It specifies the resource (project context) and the action (get), and distinguishes from siblings like get_project_info or get_project_dashboard by mentioning the 'complete situation report' with specific content categories (project info, recent activity, active agents, key decisions).

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 clear 'WHEN TO USE' section with specific scenarios: entering a project, before starting work, returning after time, and getting a full overview. This gives strong contextual guidance. It does not explicitly mention when not to use the tool or name alternative tools, but the use cases are clearly delineated.

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 behavioral traits, but it only restates the action. It does not mention return format, whether tasks of all statuses are included, pagination, ordering, or any side effects. The description adds no transparency beyond the tool's name.

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

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

The description is a single, clear sentence with no unnecessary words. It is appropriately concise and front-loaded, fulfilling the conciseness requirement perfectly.

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 and no output schema, the description is insufficient. It does not explain the return value, the need for at least one project identifier, or how filtering parameters combine. The ambiguity between project_id, project_name, and workspace_path leaves the tool incomplete for an agent to invoke correctly 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?

Schema coverage is 100%, so parameter names and basic descriptions exist. However, the relationship between project_id, project_name, and workspace_path is unclear, and the description does not clarify whether these are alternatives or required fields. The tool description adds no value beyond the schema, and the schema itself is ambiguous about parameter interplay.

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 ('Get') and resource ('all tasks') with a scope ('for a project'), making the primary purpose understandable. However, it does not differentiate from similar sibling tools like get_my_tasks or get_task, so it misses the distinction that would warrant a 5.

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

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

There is no guidance on when to use this tool over alternatives such as get_my_tasks or get_project_dashboard, nor any clarification on how the various project identifiers (project_id, project_name, workspace_path) relate. The description provides no context for choosing this tool or what distinguishes it from others.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose a key behavioral trait: the identifier resolution priority (project_id > workspace_path > project_name). However, it does not describe what the returned changes look like (since no output schema exists), error behavior, or whether the changes are scoped to the current session. The read-only nature is implicit but 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 well-structured with clear sections (opening statement, lookup behavior, priority, WHEN TO USE, RECOMMENDED). It is relatively concise for the amount of guidance it provides, though the WHEN TO USE list has some thematic redundancy (e.g., 'At the start of a session' and 'After being away' overlap). The main purpose is front-loaded.

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

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

Given the moderate complexity (5 optional parameters, no output schema), the description covers the lookup and usage guidance well. However, it does not explain the structure or contents of the returned 'recent changes' list, nor does it describe the architecture_impact_filter parameter in more detail beyond the schema. An agent would still need to infer what fields each change includes, which is a notable gap.

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

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

The input schema already covers all 5 parameters with descriptions (100% coverage). The description adds value by explaining how the project identifiers interact: the priority order for resolution. This goes beyond the individual parameter descriptions and helps the agent understand which parameters to provide and how they are handled when combined.

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

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

The description clearly states the tool's function: 'Retrieve recent changes made to a project for context and continuity.' It uses a specific verb and resource. It also describes flexible project lookup with identifier priority, which helps define its scope. However, it does not explicitly distinguish this from sibling tools like get_project_info or get_context_history, though the WHEN TO USE list provides some 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?

The description includes a dedicated 'WHEN TO USE' section with six concrete scenarios (e.g., 'At the start of a session', 'Before making changes', 'To check if another agent has been working on the same files') and a strong 'RECOMMENDED' call for resuming work. This gives explicit context for usage, but it lacks explicit when-not-to-use guidance or named 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?

With no annotations provided, the description carries the full burden. It accurately describes a read-only operation (get sent messages) with no side effects or surprises. It clarifies that the messages are ones 'you've sent to others,' which is useful context. The slight ambiguity between 'an agent' and 'you' is resolved by the second sentence and the schema's 'Your agent_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 very short (two sentences) and front-loaded with the key verb and resource. However, the two sentences are slightly redundant ('Get messages sent by an agent' and 'View messages you've sent to others' essentially repeat the same idea). Still, it is efficient and contains no fluff.

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

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

For a simple read tool with no output schema, the description adequately implies the return value (messages). It does not explain interaction between the 5 parameters (e.g., how project filtering works), but the schema already covers those details. It is complete enough 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?

Schema description coverage is 100%, so the baseline is 3. The description does not add any parameter-specific semantics beyond what the schema already provides. The meaning of agent_id, limit, and project filters is fully defined in the schema, so the description's lack of parameter detail 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's function: 'Get messages sent by an agent' and 'View messages you've sent to others.' This uses a specific verb (get/view) and a resource (sent messages) with clear scope, distinguishing it from siblings like get_messages (which likely returns all messages).

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

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

The description provides clear context for when to use the tool—when you need to view messages you've sent. It implies exclusion of received messages, though it does not explicitly name alternative tools like get_messages. This is clear enough for an agent to select appropriately.

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 claims 'complete session log' and 'full history' but the limit parameter (default 50) caps results, creating an internal contradiction. It also fails to disclose read-only nature, ordering, or pagination behavior, which is essential for a retrieval 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 uses clear headings and bullet points for readability. It is somewhat verbose with the 'USEFUL FOR' line largely repeating the 'WHEN TO USE' content, but the structure is effective and not overly long.

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 retrieval tool with no output schema, the description gives useful high-level context about the contents (events, activities, durations). However, it omits specifics like return format, ordering, and the effect of the limit parameter, making it only partially 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?

Schema description coverage is 100%, so both 'agent_id' and 'limit' are already well-documented. The tool description adds no extra parameter-specific meaning, so the baseline of 3 is appropriate.

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

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

The description starts with a specific verb ('Retrieve') and resource ('your complete session log'), clearly stating it returns events and activities. This distinguishes it from sibling tools like get_context_history or get_agent_context by focusing on the session log specifically.

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 'WHEN TO USE' section provides clear, explicit scenarios for when to invoke this tool (reviewing history, understanding context transitions, tracking duration, debugging). However, it does not mention alternatives or when not to use it, so it stops short of a full 5.

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 adequately describes the return value ('Dictionary with system_prompt content'), enumerates the included information (workflow steps, tool usage examples, best practices), and gives an example call. It does not mention potential side effects or prerequisites, but as a pure read-only getter, the risks are minimal. Overall it provides sufficient transparency for this simple 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 well-structured and front-loaded: it starts with the core purpose, then provides usage guidelines, content summary, return type, and an example. Every section serves a purpose. The example is slightly redundant but harmless. This is a model of clear, organized tool documentation.

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 (0 params, no output schema), the description is largely complete. It states the return type, the content of the returned prompt, and when to use it. The only minor gap is the exact structure of the dictionary (e.g., key name beyond 'system_prompt'), but the example and description suffice for an agent to invoke and use the tool correctly.

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

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

The tool has zero parameters, so the baseline is 4 according to the rubric. The description adds no parameter details, but none are needed given the empty schema. It correctly highlights that the tool takes no input, which is implicitly clear from 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's function: 'Get the CoordMCP system prompt with mandatory workflow instructions.' It uses a specific verb ('Get') and resource ('system prompt'), and explicitly distinguishes the content from other context/guidance tools by emphasizing 'complete system prompt' and 'mandatory workflow instructions.' This makes it unique among sibling tools like get_workflow_guidance_tool.

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 clear 'WHEN TO USE' section listing specific scenarios: at agent startup, to understand the mandatory workflow, and as a reference for best practices. However, it does not explicitly mention alternatives or exclusion cases (e.g., when to use get_workflow_guidance_tool instead), which prevents a score of 5.

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 does not disclose whether this is a read-only operation beyond the verb 'get', nor what specific fields are returned or error behavior. It adds no context beyond the tool name.

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 extraneous content. However, it is overly terse and lacks useful information, though this is not a waste of 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 tool lacks an output schema and annotations, so the description should explain return values or behavior. 'Get task details' is too vague to set expectations about what 'details' includes or any limitations.

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

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

Schema coverage is 100% for both task_id and project_id, so the baseline is 3. The description does not add any additional parameter semantics beyond the schema definitions.

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 retrieves task details, with a specific verb ('get') and resource ('task details'). However, it does not distinguish from sibling tools like get_project_tasks or get_my_tasks, lacking explicit scope (e.g., 'single task by ID').

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 get_project_tasks or get_my_tasks. 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 the transparency burden. It discloses the identifier priority (project_id > workspace_path > project_name), which is a key behavioral trait for resolution. The verb 'Retrieve' implies read-only, though it never explicitly claims no side effects or mentions error/return behavior.

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

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

The description is well-structured with a direct opening, a priority note, and a bulleted 'WHEN TO USE' section, making it scannable. The bullets are slightly repetitive (e.g., 'consistency' and 'avoid conflicts' overlap), but the overall size is justified by the multi-purpose guidance.

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, and the description does not explain what the return value looks like (format, structure, content). It also omits error cases or failure behavior. However, it covers lookup flexibility, identifier priority, and usage scenarios well enough for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds the priority rule for how the three identifier parameters interact, which is not in the schema. It also states any combination works. It does not add new semantic detail for the 'category' parameter, but the identifier interplay is valuable.

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 opening line 'Retrieve the complete technology stack for a project' uses a specific verb and resource, clearly distinguishing this read tool from siblings like update_tech_stack (write) and get_project_info (general info). The description goes further to explain flexible lookup via multiple identifiers, reinforcing its 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 'WHEN TO USE' section explicitly lists concrete scenarios (start of work, adding dependencies, version compatibility, onboarding, consistency) and recommends calling early. However, it does not explicitly name alternatives or when not to use, so it stops short of a full 5.

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 burden. It explains that it combines project-specific workflows with standard workflows and lists available workflow names, but it does not disclose side effects, return format, or behavior when parameters are omitted. The read-only nature is implied but not explicit, leaving gaps in behavioral 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 well-organized with clear section headers ('WHEN TO USE', 'AVAILABLE WORKFLOWS'), is concise, and every sentence provides useful information. The main purpose is front-loaded, making it easy to parse.

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 guidance tool with two optional parameters and no output schema, the description is fairly complete. It covers when to use, what it does, and lists available workflows. However, it does not explain the output structure or what happens when both parameters are null, leaving a small but notable gap.

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

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

The schema already includes descriptions for both parameters, achieving 100% coverage. The description adds value by listing the exact workflow names ('test-first', 'feature-branch', etc.) and their meanings, which goes beyond the schema's example-driven explanation. This enriches the parameter semantics for workflow_name.

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 provides 'phase-by-phase workflow guidance for development tasks', with a specific resource and verb. It distinguishes itself from siblings by focusing on workflow guidance and listing the available workflow types, making its role unambiguous.

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

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

The 'WHEN TO USE' section explicitly lists use cases such as 'start of any new task', 'follow best practices', and 'new agents should always call this'. It provides clear context but does not explicitly name alternatives or exclusions, which would take it to a 5.

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. The wording 'browsing' and 'overview' implies a read-only operation, but the description does not explicitly state that there are no side effects, nor does it disclose permissions, pagination, or return format. It adds moderate context but leaves some behavioral details implicit.

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 uses a bolded 'ESSENTIAL FOR' section and a bulleted 'WHEN TO USE' list, making it scannable and well-structured. However, there is some redundancy: 'This tool provides a comprehensive view of all projects in the system' and 'Get an overview of all tracked work' say essentially the same thing, and 'browsing available projects' appears twice. Slightly more repetition than ideal for a 5.

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

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

The tool is a straightforward list-with-filters operation, and the description adequately covers the main use cases and the concept of filtering. With no output schema, it could benefit from mentioning what fields are returned or any prerequisites, but for its simplicity, the provided context is sufficient for an agent to decide when to invoke it.

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

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

The schema has 100% coverage with each parameter (status, workspace_base, include_archived) having a clear description. The tool description only mentions 'optional filtering' without detailing these parameters, so it adds no extra meaning beyond the schema. This aligns with the baseline 3 for high coverage.

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 begins with 'List all CoordMCP projects' which states a specific action (list) and a specific resource (CoordMCP projects). It also mentions 'optional filtering' and lists concrete use cases like 'find projects under a specific directory' and 'check which projects are active vs archived', clearly distinguishing it from siblings like get_project or create_project.

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?

A 'WHEN TO USE' section explicitly lists several scenarios, such as seeing all projects or checking statuses, and the 'ESSENTIAL FOR' line adds context about browsing before selecting work. However, it does not mention when NOT to use this tool or name alternative tools like get_project_info for single-project details, so it falls short of a 5.

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?

Since no annotations are provided, the description carries the full burden and largely succeeds. It discloses conflict behavior, lock expiration, and coordination options, but could add more detail on lock release semantics or success responses.

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?

Well-structured with headers and bullet lists, but some redundancy exists (e.g., CRITICAL and MANDATORY both emphasize importance, and prevention bullets repeat). Length is justified by the criticality of correct usage and the detailed workflow guidance.

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

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

Covers purpose, prerequisites (via schema), workflow, and conflict handling effectively. Since there is no output schema, the description doesn't explain return values, but it does mention receiving conflict information. Missing explicit success return details but overall complete for a locking 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?

All five parameters are fully documented in the input schema with descriptions and examples. The description adds no new parameter-specific information, but schema coverage is 100%, so baseline 3 is appropriate.

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

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

The description explicitly states the tool's function: locking files before modification to prevent conflicts. It clearly differentiates from sibling tools like unlock_files and get_locked_files by defining its unique role in the workflow.

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 explicit when-to-use scenarios (editing existing files, shared directories, multi-file refactors, extended modifications). Includes a step-by-step workflow, naming lock_files as step 1 and unlock_files as step 4, plus conflict handling guidance with 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?

With no annotations, the description carries the full burden. It discloses key behavioral aspects: project lookup priority ('project_id > workspace_path > project_name'), predefined change types, architecture impact levels, and the fact that it maintains 'a complete audit trail.' It does not reveal what happens on duplicate logs, error handling, or whether it returns any response, but for a logging tool the described behavior is sufficiently 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 longer than average but well-organized with clear headings (WHEN TO USE, CHANGE TYPES, ARCHITECTURE IMPACT, BEST PRACTICES). The opening sentence is direct and impactful. However, the paragraph on 'flexible project lookup' feels slightly tangential to the primary logging purpose and could be tightened, though it remains useful 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?

Despite lacking an output schema and annotations, the description is thorough for a logging tool. It covers invocation timing, change classification, project resolution, and best practices for descriptions and related decisions. It does not explain return values, but for an audit-logging operation the agent mainly needs to know how to call it correctly, which is fully 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?

Schema description coverage is 100%, so every parameter already has a description. The tool description adds further semantic value by elaborating on the meaning and allowed values for 'change_type' (create, modify, delete, refactor) and architecture_impact (none, minor, significant) and by explaining the precedence of project identifiers. This goes beyond the schema's basic descriptors, helping the agent choose correct parameter 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 opens with 'CRITICAL: Log every significant code change for project tracking and history,' which clearly states the tool's verb ('log'), resource ('code change'), and purpose. It also enumerates concrete scenarios (creating files, modifying functionality, deleting features) and distinguishes this logging action from read-only tools like get_recent_changes or update_file_metadata in the sibling 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?

Provides explicit usage mandates: 'MANDATORY: Call this AFTER completing any substantial file modification' and a 'WHEN TO USE' section listing exact situations. It also specifies the best practice to log 'after the change is complete and tested.' No alternative tools are referenced, but this is a mandatory audit-logging tool, so the guidance fully covers when and how to invoke it.

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

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

With no annotations provided, the description carries full responsibility for disclosing behavioral traits such as side effects, permissions, idempotency, or return values. The description only states the basic action, providing no additional behavioral 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, concise sentence with no wasted words. It is efficiently structured, though its brevity results in a tautological statement that doesn't add value beyond the tool name.

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

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

This is a mutation tool with no annotations, an output schema, or contextual details about side effects, return values, or usage context. The description does not explain what 'read' means in this system, which agent context applies, or how project_id/project_name/workspace_path influence the operation, making it incomplete for a 5-parameter 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?

The input schema provides complete descriptions for all 5 parameters, achieving 100% coverage. The tool description itself adds no parameter-specific details, but the schema already handles this dimension, making the baseline score of 3 appropriate.

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

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

The description 'Mark a message as read.' directly restates the tool's name 'mark_message_read' without adding any additional detail or context. While it clearly identifies the action, it provides no differentiation beyond what the name already conveys.

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 offers no guidance on when to use this tool compared to sibling tools like send_message, get_messages, or broadcast_message. There are no stated prerequisites, alternatives, or exclusions, leaving the agent to infer usage entirely 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?

With no annotations provided, the description carries the full burden. It does explain the mandatory ordering, side effects (context tracking, file locking, change attribution, session history), and the need to save the agent_id. It could disclose more about idempotency or error behavior, but overall it is transparent about its role.

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 front-loaded with the critical 'MANDATORY STEP 2' instruction and organized into sections (WHEN TO USE, WORKFLOW). It is slightly verbose but every section reinforces necessary context, and the structure aids navigation.

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 is integrated into a multi-agent coordination workflow, the description provides all required context: prerequisites, sequential ordering, benefits, and follow-up action. It is complete for successful 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 input schema provides 100% parameter coverage with clear descriptions for agent_name, agent_type, capabilities, and version. The tool description adds no additional parameter-specific meanings, though it does mention saving the returned agent_id. This matches the baseline for high schema coverage.

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 'Register yourself as an agent in the CoordMCP system' with a specific verb and resource. It distinguishes itself from sibling tools like start_context and get_agent_profile by establishing its place as the mandated second step in the workflow.

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 'WHEN TO USE' section explicitly lists scenarios such as at the start of every session or after reconnecting, and the workflow shows the exact sequence with create_project and start_context. It lacks an explicit 'when not to use' statement, but the mandatory context makes exclusions evident.

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 must disclose behavioral traits. It only says decisions are recorded for future reference but does not explain what happens on invocation—whether it creates a new record, returns an ID, requires project context, or has side effects. This is a significant gap 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 well-structured with headers and bullet lists, but it is verbose with repeated emphasis ('CRITICAL', 'MANDATORY') and a lengthy 'WHY THIS MATTERS' section. It is front-loaded and readable, yet could be more 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?

The description thoroughly covers when and why to use the tool, but omits behavioral expectations such as return values, side effects, or prerequisites. Given no annotations and no output schema, it is sufficient for basic invocation but lacks completeness for a tool with 11 parameters and mutation 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?

Schema description coverage is 100%, so all 11 parameters are already documented. The description adds general guidance about what kinds of decisions to save but does not add parameter-level meaning beyond the schema. The baseline of 3 is appropriate.

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

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

The description clearly states the tool records important architectural and technical decisions, using a specific verb ('Record') and resource ('decisions'). It effectively distinguishes from sibling retrieval tools like get_project_decisions and search_decisions by emphasizing the act of saving decision history.

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 detailed 'WHEN TO USE' section with concrete examples (framework choices, database selection, architecture patterns, etc.) and declares it mandatory for significant technical choices. However, it does not mention alternatives or exclusions, so it stops short of a 5.

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 fully disclose behavior. It does explain the priority order for project identifiers (project_id > workspace_path > project_name) and mentions you can specify any combination. However, it does not clarify how query and tags interact (AND vs OR), what fields are returned in results, or why the project lookup sentence is included. This leaves room for uncertainty.

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 well-structured with a clear opening sentence, a priority note, and structured WHEN TO USE/USEFUL FOR sections. While it is moderately long, every section contributes meaningful guidance. The USEFUL FOR section is slightly redundant with WHEN TO USE but not excessively so.

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 5 parameters and no output schema, so the description must cover more ground. It explains the core purpose, usage scenarios, and identifier priority, but omits details about result structure, filtering behavior with tags, or potential edge cases. This leaves some gaps but still provides a usable baseline for an 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?

Input schema descriptions already cover all parameters with 100% coverage, so baseline is 3. The description adds extra value by explicitly stating the resolution priority for project identifiers and providing example tag values, giving users a clearer mental model of precedence and 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 'Search through recorded decisions by keywords or metadata' and the WHEN TO USE section reinforces specific decision-related use cases. This distinguishes it from sibling tools like get_project_decisions, which likely list all decisions without keyword search. The initial phrase 'flexible project lookup' adds slight ambiguity but does not undermine the core 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 WHEN TO USE section provides explicit scenarios with concrete examples (e.g., 'Looking for decisions about specific topics', 'Checking if a particular technology was already decided upon'). It does not explicitly name alternatives, but the context makes it clear this is the right tool for targeted decision search rather than general project listing.

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?

There are no annotations, so the description must fully disclose behavior. It discloses the ability to target or broadcast, but does not mention message persistence, delivery semantics, or any side effects. 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?

Three sentences, but the second and third sentences repeat the broadcast idea. Still concise and front-loaded, though not maximally efficient.

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

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

For a simple messaging tool with no output schema, the description covers the core purpose but omits details like whether messages are stored, delivery guarantees, or how to confirm sending. Given the presence of related siblings (get_messages, broadcast_message), more context could help.

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 covers 100% of parameters, so baseline applies. The description does not add any details about parameters beyond the schema; it merely mentions broadcast which is already in 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 action ('Send a message') and the resource ('another agent'), including the broadcast option. However, it does not differentiate from the sibling tool 'broadcast_message', which may cause confusion about when to use which.

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

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

It provides context that this is for communication between agents on the same project, but does not specify when to use this tool instead of alternatives like 'broadcast_message' or 'get_messages'. No exclusions or conditions are given.

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

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

With no annotations, the description carries the full transparency burden. It explains that the tool enables context tracking, file locking coordination, session logging, and conflict prevention, and it defines the priority value meanings. It does not discuss error conditions or return values, but the core behavior is well disclosed.

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 organized into labeled sections with a clear front-loaded purpose statement. Each section (WHEN TO USE, WORKFLOW, PRIORITY LEVELS) contributes unique information without redundancy, making it appropriately sized and easy to parse.

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

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

The description covers the tool's role in the workflow, prerequisites, usage scenarios, and parameter semantics. It also provides a recommended sequence of operations (steps 1-5). Given the absence of an output schema, the description is sufficiently complete 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 documents all 9 parameters with 100% coverage. The description adds value by specifying the project lookup priority order (project_id > workspace_path > project_name) and by elaborating on the semantic meaning of each priority level. This goes beyond the schema's basic field 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 opening sentence 'Start a new work context before beginning any coding task' uses a specific verb and resource, and the 'MANDATORY STEP 3' framing distinguishes it from lifecycle siblings like switch_context and end_context. It clearly states what the tool does and why it is necessary.

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 'WHEN TO USE' section enumerates explicit scenarios (every coding session, switching objectives, after task completion), and the workflow defines prerequisites (after create_project and register_agent). However, it does not explicitly contrast with switch_context or state when not to use it, so it falls short of a perfect 5.

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

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

No annotations are provided, so the description carries full responsibility. It clearly warns that the tool will end the current context and start a new one, instructs to complete pending work first, and includes a workflow with unlock/lock files. This goes beyond the basic operation and discloses important 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 well-structured with WHEN TO USE, IMPORTANT, and WORKFLOW sections. Every sentence adds value, and the format is scannable and front-loaded with the main 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?

For a state-changing tool with a workflow, the description includes the critical warning about ending context, when-to-use triggers, and a step-by-step workflow. It does not explain return values, but no output schema exists and the operation is straightforward.

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?

Input schema covers 100% of parameters with descriptions, so baseline is 3. The description adds no parameter-specific details, but the schema already documents each field sufficiently (agent_id, priority, to_objective, etc.).

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 'Switch your work context to a different project or objective' with a specific verb and resource. The WHEN TO USE section further distinguishes it from siblings like start_context and end_context, making the purpose unambiguous.

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

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

Provides explicit WHEN TO USE list covering common switching scenarios (user request, task change, multi-project work, post-completion). It does not explicitly name alternative tools or when NOT to use, but the context is clear enough for an agent to decide.

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 transparency burden. It explains the effect of unlocking (allows other agents to work, prevents blocking) and includes a workflow, but does not disclose edge-case behaviors like ownership requirements or error conditions. Still, it provides meaningful context beyond the bare action.

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 uses clear headers, bullet points, and a numbered workflow, making it easy to scan. While it is longer than strictly necessary, the structure front-loads the core purpose and organizes guidance logically, with no fluff.

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 straightforward lock-release tool with three simple parameters and no output schema, the description covers the purpose, timing, and workflow comprehensively. It integrates with sibling tools like log_change without overcomplicating, making it sufficiently complete for agent decision-making.

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 100% coverage with detailed descriptions and examples for all three parameters. The tool description does not add additional parameter-level meaning, so a baseline of 3 is appropriate.

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

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

The description begins with a specific action verb 'Release' and a clear resource 'file locks', making the tool's purpose immediately obvious. It distinguishes itself from sibling tools like lock_files by specifying the reverse operation.

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 an explicit 'WHEN TO USE' section with concrete scenarios (after changes, before switching files, at session end). It also includes an 'IMPORTANT' note about unlocking promptly and integrates with a workflow step after log_change(), giving clear sequencing 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 carries the transparency burden. It describes the tool's actions (logging implementation details, tracking files, updating history, documenting deviations) and the flexible lookup priority. However, it does not disclose error behavior or return values, which would be useful for full 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 well-structured with clear sections (purpose, when-to-use, important, workflow), but it is somewhat verbose and slightly repetitive (e.g., the purpose is restated in the 'Important' list). Overall, it earns its length by providing substantial guidance.

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

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

The description covers the tool's purpose, workflow, and parameter semantics comprehensively, making it highly usable for an agent. However, without an output schema, a note about return values or success indication would enhance 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?

Schema description coverage is 100%, so the description adds value by explaining the lookup priority (project_id > workspace_path > project_name) and clarifying that recommendation_id is required and ties to get_architecture_recommendation(). This goes beyond the schema's individual field 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 clearly states the verb and resource: 'Update the project architecture tracking after implementing recommendations.' It also differentiates from siblings like update_tech_stack and log_change by focusing on architecture tracking and recommendation implementation.

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 dedicated 'WHEN TO USE' section with explicit scenarios and a workflow that references get_architecture_recommendation() and log_change(), clearly guiding the agent on when to invoke this tool versus 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, so the description carries the full burden. It discloses project resolution priority (project_id > workspace_path > project_name) and enumerates file types and complexity levels. However, it never states update semantics: whether it overwrites all fields, merges provided fields, or what happens when metadata already exists. This is a significant gap for an 'update' 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 overly long (approximately 250 words) and repetitive. It re-lists schema values for file types and complexity levels, includes promotional filler like 'RECOMMENDED FOR' and 'This helps build a dependency graph', and the off-topic project lookup paragraph adds confusion rather than 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?

The description includes usage scenarios, project lookup priority, and value enums, which is helpful. However, it lacks critical behavioral details about the update operation itself, such as whether partial updates merge or replace existing metadata, and it does not mention any output or acknowledgment. Given the rich schema, it is functional but incomplete.

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

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

Schema coverage is 100%, and each parameter already has a clear description. The description adds value by clarifying project identifier priority and by enumerating file type/complexity values, but these are also present in the schema. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description opens with 'Track important file metadata' but then shifts to 'This tool provides flexible project lookup' and discusses identifier resolution priority, which is more appropriate for a project lookup tool. The verb 'track' is ambiguous compared to the tool name's 'update', though the WHEN TO USE section clarifies it updates file metadata by listing scenarios like 'update complexity assessments'.

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 an explicit WHEN TO USE section with five concrete scenarios (after creating new files, understanding dependencies, updating complexity, organizing modules, refactoring). It does not name alternatives or exclusions, but the scenarios are clear enough to guide an agent. The RECOMMENDED FOR section adds further targeting.

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 shoulders the full burden of behavioral disclosure. It only states the action and reveals nothing about side effects, required permissions, or what happens to the task, leaving the agent to guess the consequences of 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?

While the description is brief (four words), it is under-specified rather than effectively concise. It merely restates the tool name and omits essential context, so brevity comes at the cost of usefulness.

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

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

This mutation tool has five parameters, four required, and no output schema or annotations. The one-sentence description fails to explain expected behavior, return values, or prerequisite conditions, making it inadequate for an agent to safely 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 100%, so all five parameters are documented in the schema. The description adds no additional meaning, but the baseline of 3 applies since the schema already covers the parameter details.

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

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

The description uses a clear verb and resource ('Update task status'), which directly identifies the action. It lacks scope details or differentiation from sibling tools like complete_task or assign_task, but the core purpose is unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as complete_task or create_task. There are no prerequisites, context, or explicit exclusions, leaving the agent without decision 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?

With no annotations, the description carries the transparency burden. It reveals side effects ("creates a central registry"), lookup flexibility, and identifier priority (project_id > workspace_path > project_name). However, it doesn't disclose behavior like overwrite semantics, error handling, or reversibility, so it falls short of a 5.

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 long but well-structured with headings (WHEN TO USE, CATEGORIES, BEST PRACTICE) and bullets. Each section earns its place; the repeated "CRITICAL" and "MANDATORY" emphasis is slightly redundant but not excessive.

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

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

For a tool with 8 params and no output schema, the description covers use cases, categories, lookup behavior, and best practices. It lacks explicit return value details or failure scenarios, but given no output schema, it is reasonably 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?

Schema coverage is 100%, providing descriptions for all 8 parameters. The description adds value by explaining the priority order for project lookup, listing category examples, and recommending decision_ref usage—enhancing the schema's static definitions.

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: "CRITICAL: Record the technology stack used in this project" and "This creates a central registry of all technologies used." It uses a specific verb (record/update) and resource (tech stack), and the mandate distinguishes it from read-only siblings like get_tech_stack.

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 an explicit "WHEN TO USE" list covering setup, new dependencies, version changes, infrastructure, databases, testing, and CI/CD. It also gives category examples and best practices, offering clear guidance on when to invoke this tool versus 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?

With no annotations, the description carries the full burden for behavioral disclosure. It does disclose the priority order for project lookup (project_id > workspace_path > project_name) and enumerates validation checks, which adds useful context. However, it does not state whether the tool performs side effects, what happens on validation failure, or how strict_mode changes behavior beyond the schema, leaving gaps in 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 well-structured with clear section headers (WHEN TO USE, VALIDATION CHECKS) and front-loads the core purpose. It is somewhat verbose with overlapping points between 'USEFUL FOR' and earlier statements, but overall each section earns its place and is not excessively padded.

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

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

The description covers usage scenarios and validation checks, which is beneficial given the tool's complexity (6 params, nested objects). However, with no output schema, it does not explain the return format or how results are presented (e.g., list of violations, success/failure), nor does it discuss error handling. This leaves the description incomplete for an agent to fully anticipate the tool's response.

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 100% coverage, so the baseline is 3. The description adds meaning beyond the schema by explaining the flexible lookup behavior ('You can specify any combination of identifiers') and the priority order among project_id, workspace_path, and project_name. This enriches understanding of how parameters interact, going beyond the individual property descriptions.

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