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

No annotations are present, so the description alone must disclose behavior. 'Prepare' hints at a setup action, but the description says nothing about side effects, whether providers are contacted, whether a workflow object is returned, or how rounds/models affect execution.

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 definition is only one sentence with no filler, so it is concise, but it is under-sized for a required-mode, 4-parameter workflow tool. A single abstract phrase conveys too little structure and leaves no detail hierarchy for an agent to use.

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

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

Given four parameters, a required collaboration mode with no enum values, no annotations, and no output schema, the description is far from complete. An agent has no way to know the outcome of calling the tool, what 'prepare' produces, or how models, rounds, and collaboration_mode interact.

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 four parameters, so the baseline applies even though the tool description itself adds little meaning. There is no explanation of what collaboration_mode values are valid or what an empty models string means, but this is a moderate gap rather than a complete failure.

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 offers a verb and resource ('Prepare... collaboration workflow'), so it is not a tautology. However, 'prepare' is abstract—it does not state whether this starts the collaboration, returns a plan, or configures providers—and it does not differentiate the tool from sibling planning/collaboration tools like coeus_multi_model_verify, coeus_critical_debate, or coeus_workflow_automation_plan.

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 zero guidance about when this tool should be chosen over the many alternative collaboration, verification, and planning tools. The description does not mention prerequisites, common use cases, or exclusions, so an agent cannot decide when to call 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only reveals that the tool is an umbrella and that mode selects among three options, which mostly restates the input schema. It does not describe what each mode does, what inputs it relies on, what side effects or access needs exist, or what kind of output the agent should expect.

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

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

The description is short and front-loaded, with no wasted words. However, it is under-specified rather than elegantly concise, and it mostly repeats information already present in the mode enum and tool name. It earns partial credit for brevity but not for informative structure.

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?

There is no output schema, no annotations, and the description does not explain expected results for any of the three modes. For a four-parameter dispatcher with three distinct behaviors, an agent needs at least a brief account of what summarize, map, and explain produce, plus when each mode is appropriate. The current description leaves that entirely to inference.

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 even though the property descriptions are minimal ('Mode', 'Model', 'Target', 'Question'). The description adds essentially no meaning beyond the schema, unless the phrase 'mode is summarize, map, or explain' is considered reinforcement of the enum. It does not explain how question and target relate to the selected mode or what valid target values look like.

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 identifies the tool as an umbrella for summarize, map, and explain modes, and the enum values confirm those modes. However, it lacks a concrete verb and resource, so it never actually states what the tool does beyond routing. It is not a tautology, but it is too abstract to fully distinguish the tool's real behavior from its siblings.

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

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

The description implies that selecting a mode determines the analysis type, but it gives no explicit guidance on when to use this umbrella tool versus dedicated siblings like coeus_summarize, coeus_codebase_map, or coeus_explain_code. No exclusion criteria or alternative-selection logic is provided, so an agent cannot know whether to call this tool or a more specific one.

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

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

With no annotations, the description must carry the behavioral burden, but it only says the tool 'asks' and is 'large-context.' It does not disclose effects, prerequisites, cost, return behavior, or whether any state changes, and no safety profile is provided.

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 entire necessary message fits in one front-loaded sentence that places the action and key differentiator ('large-context', 'ignore guidance') first. There is no repetition or filler.

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

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

For a 5-parameter tool with no annotations and no output schema, this description is under-specified. An agent still lacks enough information to know exactly what model/scope values mean, what the response will be, and when it should be invoked among many similar codebase-analysis siblings.

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, so the baseline is 3 even though those descriptions are just names. The description adds some semantic color by mapping target to 'directory or @file set' and ignore to 'guidance,' but it does not clarify model or scope.

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

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

The description clearly states the tool asks a large-context question about a directory or @file set, with ignore guidance, so the core action and target are identifiable. However, it does not differentiate this tool from siblings such as coeus_analyze, coeus_ask, or coeus_codebase_map.

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 explicit guidance on when to choose this tool over alternatives, and no exclusions or alternative tool names are mentioned. The 'directory or @file set' phrase implies a codebase-analysis context, but only weakly.

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 carries the full burden of behavioral disclosure. It does reveal a meaningful trait—calls are provider-neutral and routed—but it does not explain what happens with provider=auto, whether calls are synchronous, what the response shape is, or any side effects or side effects like cost/rate limits.

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

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

A single sentence that is front-loaded with the action and key qualifiers. There is no redundant or filler wording; it earns its place without being 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 tool is complex—13 parameters, 5 enums, no output schema, and no annotations—so one sentence is insufficient. The agent is left without context about how the routed provider is selected, what the returned content looks like, or how parameters like thinking_budget and reasoning_effort affect 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 the baseline is 3 even though the description adds no parameter-specific meaning. The tool description itself does not clarify enum semantics like 'speed' or 'budget', but the schema at least names and types each parameter, so no severe documentation gap exists.

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 ('Make') with a clear resource ('provider-neutral prompt call') and a defining qualifier ('routed model provider'). It is not a tautology and conveys the core function, but it does not explicitly distinguish itself from closely related sibling tools like coeus_route or coeus_analyze.

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 about when to use this tool versus alternatives. The phrase 'provider-neutral' weakly implies a general-purpose prompt call, but there are no explicit when-to-use, when-not-to-use, or alternative routing conditions given the many sibling tools.

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

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

With no annotations, the description carries the behavioral burden. 'Truthful live inventory' adds meaningful context about freshness and accuracy, but it does not disclose side effects, output format, error behavior, or whether any runtime state is queried. For a simple zero-parameter read-only tool 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?

A single, front-loaded sentence with no filler. Every phrase earns its place, and the key content categories are listed compactly.

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 introspection tool, the description is largely sufficient: it names the content domains and implies live, truthful data. Since there is no output schema, a bit more detail about the response shape would strengthen completeness, but the absence does not block correct invocation.

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

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

The tool has zero parameters and the schema is already complete at 100% coverage, so the baseline is 4. The description adds value by enumerating the inventory categories (tools, providers, capability packs, experimental flags), which tells the agent what the response will cover.

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 ('Return') and names a clear resource: a live inventory of tools, providers, capability packs, and experimental flags. This distinguishes it from sibling tools like coeus_list_models (models only) and coeus_runtime_diagnostics (diagnostics only).

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

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

No explicit guidance is given about when to use this tool versus any of the many sibling tools. The phrase 'live inventory' implies current-state discovery, but there is no stated exclusion or comparison such as 'use this when you need a full capability list rather than health or diagnostics.'

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 to indicate destructive or side-effect behavior, so the description carries the full burden. It does add one useful trait — the session is in-memory, implying ephemerality — but it does not disclose whether the action is irreversible, whether it affects persisted conversation data, or what happens to the session after being cleared.

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 one short, focused sentence with no filler or repetition. It front-loads the action and resource immediately and every word contributes to understanding.

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 only one parameter and a simple schema, the tool performs a potentially destructive action with no annotations and no output schema. The description does not explain expected return behavior, side effects, or usage context, leaving an agent to guess important aspects of invoking 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 documents conversation_id with 100% coverage, so the baseline is 3. The description adds no additional meaning about where the ID comes from, what format it should have, or how to obtain it, but it does nothing to make the parameter harder to understand.

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 ('Clear and a specific resource ('an in-memory conversation session'), and it is easily distinguished from conversation-related siblings like start_conversation, continue_conversation, and list_conversations. It could be slightly more explicit about whether this deletes the session record or simply resets its context, but the core purpose is understandable.

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

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

No guidance is given about when this tool should be used instead of start_conversation, continue_conversation, or list_conversations. Usage context is only implied by the operation name, so an agent receives no explicit selection 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 full burden of behavioral disclosure, but it only states the action without explaining side effects, read-only nature, or output characteristics. It does not clarify what 'large-context' implies or what the result is.

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 unnecessary wording. It is efficiently structured, though its brevity leaves critical details unaddressed.

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 4 parameters, no output schema, and no annotations, the description is severely incomplete. An agent would not know how to fill parameters or interpret results, making the tool difficult to use correctly.

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

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

The description does not explain any parameters. The schema descriptions are merely single-word labels ('Focus', 'Model', 'Ignore', 'Target') that provide no meaningful semantics, and the description does not compensate for this lack of clarity.

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

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

The description states a clear verb ('Produce') and a specific resource ('architecture map') for a directory or @file set. It is unambiguous in intent, but does not distinguish itself from sibling tools such as coeus_analyze_codebase, which may also analyze codebases.

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. The description does not mention scenarios, exclusions, or when to prefer other tools like coeus_stats or coeus_analyze.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states what the tool does but does not describe side effects, return shapes, failure modes, or the meaning of the output_format and include_metrics parameters, leaving the agent to guess behavioral 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 names the action and resource immediately, with zero filler. It is appropriately sized for the simple purpose it conveys, and every word contributes to 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 annotations, no output schema, six parameters, and numerous sibling tools, a one-sentence description is insufficient. It omits input formats for sources, output behavior, and when to prefer this tool over comparable siblings, leaving important operational gaps.

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

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

Schema description coverage is 100%, so the baseline baseline is 3. However, the schema descriptions are mostly tautological labels like "Model", "Sources" and "Output format". The description does add effective semantics for comparison_type by listing semantic, structural, factual, and code modes, but it does not clarify what values "sources" or "focus_areas" should take.

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 "compare" and the resource "multiple sources", and enumerates four comparison modes: semantic, structural, factual, or as code. It is not a tautology, but it does not name or differentiate itself from sibling comparison/review tools like coeus_multi_model_verify or coeus_review_code.

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

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

The description conveys an implied use case (comparing sources), but provides no explicit context about when to choose this tool over alternatives, no exclusions, and no prerequisites. There is no guidance distinguishing it from similar sibling tools.

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

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

With no annotations, the description carries the full behavioral burden. It does add useful context by calling the session 'in-memory', which signals ephemeral statefulness and that the conversation must already exist. However, it does not disclose what side effects occur, how invalid conversation IDs are handled, or whether the model defaults to something when omitted.

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 action and key constraint without filler. Every word earns its place, and the essential 'existing' and 'in-memory' qualifiers are packed in efficiently.

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

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

Given no output schema and no annotations, the description is minimally adequate: it states the action and the main constraint. However, it leaves gaps around how to obtain a valid conversation_id, the relationship to start/list/clear conversation tools, and what the response represents, so it is not fully complete for an unannotated stateful 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 the schema already documents all three parameters. The description adds no extra meaning beyond the schema; the roles of conversation_id and prompt are left to their names and schema descriptions, and 'model' is only vaguely described as 'Model'.

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

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

The description uses a specific verb ('Continue') and resource ('existing conversation session'), and the qualifier 'existing' distinguishes it from starting a new conversation. This clearly differentiates it from sibling tools like coeus_start_conversation and coeus_list_conversations without needing to open the schema.

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

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

The word 'existing' implies the tool should be used after a conversation has been created, but there is no explicit guidance on when to use it versus alternatives like coeus_start_conversation or coeus_clear_conversation. No prerequisites, exclusion criteria, or explicit routing conditions are provided.

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 states the outcome but not how the tool behaves: whether it is read-only, requires external LLM calls, or has side effects. It also omits details about model/provider configuration that are present in the schema, leaving the agent without essential operational context.

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

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

The description is a single, focused sentence that immediately states the purpose and outcome. No wasted words or redundant phrasing. It is efficiently structured 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?

The tool has 12 parameters, no output schema, and no annotations. The description is far too brief to cover operational details: it does not explain required parameters, the meaning of 'scenarios', configuration options, or what the agent should expect as a result. This is severely inadequate 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?

Schema coverage is 100%, so the baseline is 3. However, the schema descriptions are minimal (e.g., 'Code', 'Diff'), providing little semantic value. The tool description adds no parameter information, leaving parameters like 'target' and 'scenarios' unexplained. This does not compensate for the shallow schema descriptions but meets 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 states a specific verb (review) and resource (a change) with a clear outcome (expose hidden state, dependency, and release risks). The counterfactual angle distinguishes it from sibling review tools like coeus_review_code or coeus_review_pr, though it could be more explicit about the input format (code/diff) without relying on the schema.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The purpose implies using it when considering alternate futures, but it does not state when not to use it or what to use for standard reviews. An agent must infer the appropriate context from the description alone.

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

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

The description discloses the core behavior: an adversarial debate and a result aimed at flaws and mitigations. With no annotations, though, it does not indicate return format, model-invocation behavior, or cost/latency implications, leaving some behavioral expectations 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 is a single, front-loaded sentence with no filler. It efficiently communicates action, input scope, and purpose.

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

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

Given eight parameters, no output schema, and no annotations, one sentence is insufficient. It omits return structure, depth semantics, timeout behavior, and how the model-related parameters work together, leaving meaningful gaps for an agent deciding whether and how to 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 coverage is 100%, so the baseline applies. The description adds marginal value by hinting that 'content' is the plan, design, or code snippet being debated, but it does not clarify ambiguous parameters like 'context', 'adversarial_points', or how the red/blue/synthesis models should be selected.

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 action ('Execute'), a targeted resource type ('plan, design, or code snippet'), and a clear outcome ('critical flaws and mitigations'). The 'Red Team vs Blue Team' framing distinguishes it from sibling review tools without ambiguity.

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

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

The phrase 'to identify critical flaws and mitigations' gives clear context for when the tool should be used, and the enumerated input types define acceptable targets. However, it does not explicitly compare against alternatives like coeus_second_opinion or coeus_counterfactual_review.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It states the tool creates code but does not mention any side effects, such as writing files, modifying the project structure, or requiring specific permissions. It also fails to disclose what happens if the design direction is not approved, or any output format or error behavior. This is a significant gap for a tool that likely produces files.

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

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

The description is a single, efficient sentence that front-loads the primary action and context. It avoids unnecessary words and conveys the core purpose quickly. However, it is arguably too brief given the tool's complexity, but conciseness is about economy of language, which it achieves.

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 8 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain the pipeline context, what each parameter means, what the output looks like, or any prerequisites. An agent would have little idea how to construct a valid call or interpret results. The description is insufficient for correct usage.

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

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

The input schema has 100% description coverage, but each parameter description is simply the parameter name (e.g., 'Model' for 'model'), adding no semantic value. The tool description itself does not elaborate on any parameters, leaving the agent to infer meanings from names like 'model', 'states', 'variants', which are ambiguous. The description fails to compensate for the schema's lack of meaningful detail.

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

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

The description states a clear action: 'Create stylesheet-backed component code' and specifies the input context: 'from an approved design direction' and the pipeline position 'pipeline step 3'. This distinguishes it from design-focused siblings like coeus_frontend_design_brief and coeus_frontend_taste_direction, which produce design artifacts rather than code. However, it does not explicitly name any sibling alternatives, so it's clear but not fully differentiating among code-generation tools like coeus_generate_tests or coeus_refactor_code.

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

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

The phrase 'pipeline step 3' hints at a sequential workflow but does not explain what precedes or follows it, nor does it state when to use this tool versus others. There is no explicit mention of when not to use it or what conditions must be met (e.g., having an approved design direction). This leaves the agent with minimal guidance on selection.

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

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

With no annotations provided, the description carries the full burden of explaining behavior. It only lists outputs ('hypotheses, experiments, and logging or instrumentation plan') and does not disclose whether 'create' means generating a returned plan, persisting state, calling a model, or whether 'preview_only' alters side effects.

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

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

The description is a single sentence, front-loaded with the verb and main deliverables. It is appropriately compact, although the list of outputs is somewhat dense and could be structured with clearer separation.

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 six parameters, no annotations, and no output schema, the description is too thin to give an agent complete guidance. It does not explain expected return values, how constraints or provider affect the plan, or what 'preview_only' controls, leaving important call-time decisions ambiguous.

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 even though the description adds no parameter detail. The schema's property descriptions are terse ('Symptom', 'Model', 'Provider'), but the description itself does not enrich or clarify any parameter semantics beyond what the schema already 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 uses a specific verb ('Create') and identifies the resource: debugging hypotheses, experiments, and a logging/instrumentation plan. It is clear enough to suggest a debugging-oriented planning tool, though it does not explicitly distinguish itself from sibling planning tools like coeus_test_strategy or coeus_eval_plan.

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 word 'debugging' and the required 'symptom' parameter imply this tool is for investigating a bug symptom, providing some usage context. However, there is no explicit statement of when to use it versus similar sibling tools, nor any exclusion 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 full burden. It says 'Review' but doesn't disclose what the review produces (a score? feedback? pass/fail?), whether it modifies anything, or what 'frontend taste criteria' means in practice. For a tool with no annotations, this is a significant gap in behavioral disclosure.

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

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

A single, well-structured sentence that front-loads the action and resource. It's concise and readable, though it could be slightly more informative about output or criteria without becoming bloated.

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 review tool with no output schema and no annotations, the description is thin. It doesn't explain what the review returns, how the 'standards' parameter interacts with 'frontend taste criteria', or how this differs from coeus_design_review_bundle and coeus_counterfactual_review. An agent would need to open the schema and guess at expected output format.

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 schema already documents all four parameters. The description adds the meaning of 'artifact' (screenshot, rendered HTML/CSS, or design artifact) and 'frontend taste criteria' as the standard, but doesn't elaborate on 'model', 'context', or 'standards' beyond their names. 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 states a specific verb ('Review') and resource ('a screenshot, rendered HTML/CSS, or design artifact') against 'frontend taste criteria'. This clearly distinguishes it from code review tools like coeus_review_code and git_diff_review, though it doesn't explicitly name a sibling. The purpose is clear and actionable.

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

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

The description implies when to use this tool: when you have a visual/design artifact to evaluate against frontend taste. However, it doesn't explicitly state when NOT to use it or name alternatives like coeus_design_review_bundle or coeus_frontend_taste_direction. The context is clear but exclusions are absent.

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 disclosing behavioral traits. It only says 'Review ... with concrete implementation fixes', which implies analysis and suggestions but does not disclose whether the tool modifies files, has side effects, requires specific permissions, or how it handles inputs. There is no mention of output format, error behavior, or limitations. This is a significant gap for a tool that could potentially interact with file systems.

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

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

The description is a single sentence of 12 words, with no filler or redundancy. It is front-loaded with the action and targets. It is appropriately concise for a tool that likely requires more explanation, but the brevity itself is a strength. Every word earns its place.

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

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

For a tool with 8 parameters, no annotations, no output schema, and no behavioral details, this description is severely incomplete. It does not explain what 'concrete implementation fixes' means, which parameters are required or optional, how to supply the screenshot path, or what the tool returns. An agent would have to inspect the schema (which itself is unhelpful) or infer from the name. This falls far short of being a complete description 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?

Schema description coverage is 100% (each parameter has a description), so the baseline is 3. However, the parameter descriptions like 'Css', 'Html', 'Goals', 'Model', etc., are essentially tautological echoes of the parameter names, adding no meaning. The tool description itself says nothing about parameters. Since the schema descriptions technically cover all parameters, the description does not need to compensate, but it also adds no value, so a 3 is the correct 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 the tool's action ('Review') and its targets ('screenshot, HTML, and CSS artifacts') with a specific outcome ('concrete implementation fixes'). This is not a tautology and is specific enough to convey the basic purpose. However, it does not distinguish from siblings like 'coeus_design_review' or 'coeus_review_bundle', which likely overlap in function, so it earns a 4 rather than 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 versus alternatives. The description does not mention any conditions, prerequisites, or exclusions. For example, it does not say 'use this for bundled artifacts' or 'use design_review instead for standalone reviews'. Thus, usage guidance is absent, not misleading, so a score of 2 is appropriate.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals the comparison operation and scope, but does not state whether the tool is read-only, what it returns, how the live registry is accessed, or what side effects might occur.

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 one compact, front-loaded sentence with no filler; every word contributes to defining the task. It is appropriately sized, even if other dimensions are underexplained.

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 at least hint at the result shape, the meaning of drift, or what 'live registry' refers to. It only provides the action and target, leaving the agent to guess invocation expectations.

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% for both parameters, so the baseline is 3. The description loosely aligns with docs_path by mentioning README/docs/examples, but it adds no additional meaning about include_legacy or path expectations 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 uses a clear verb-resource pair: 'Compare README/docs/examples against the live registry' and distinguishes it from siblings like coeus_generate_docs by signaling a comparison rather than generation. It is clear, though 'live registry' is left undefined and no sibling is explicitly contrasted, so it stops short of a 5.

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

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

The description states what the tool does but gives no guidance on when to select it over similar tools like coeus_healthcheck, coeus_runtime_diagnostics, or coeus_generate_docs. There are no conditions, exclusions, or alternative routing hints, so the usage context must be inferred entirely.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only lists evaluation criteria and does not disclose the output format, whether model/context/requirements affect behavior, or any side effects. The absence of these details leaves the agent guessing.

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 filler. Every phrase contributes to understanding the tool's purpose, which is appropriate given the simple input schema.

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 no annotations, no output schema, and four parameters, this description is incomplete. It does not explain how the optional model/context/requirements parameters are used or what the evaluation result looks like, so an agent cannot confidently predict the invocation or 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?

Schema description coverage is 100%, so the schema nominally documents all four parameters, but those descriptions are tautological ('Plan', 'Model', 'Context', 'Requirements'). The tool description adds only marginal meaning by linking 'requirement fit' to the requirements parameter, so it barely meets 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 names a specific verb (Evaluate), a distinct resource (implementation plan), and the key criteria (feasibility, risk, requirement fit). It is clear but does not explicitly contrast it with similar sibling tools like coeus_project_task_plan or coeus_review.

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 choose this tool over alternatives, nor any exclusions, prerequisites, or conditions of use. The intended context is only implied by the name and one-line purpose, which is not enough for a tool with many sibling planning/review 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 only says 'explain' with no disclosure of side effects, return format, or any behavioral nuances. There is no mention of what happens to the input or what the output looks like, which is critical for an agent to safely and correctly invoke the tool.

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

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

The description is a single concise sentence, front-loaded with the action ('Explain supplied source code') and immediately mentioning the optional focus areas. There is no fluff or repetition. It is highly efficient.

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

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

Given the tool has 8 parameters (1 required), no output schema, and no annotations, the description is far too minimal. It does not explain what the tool returns, how to specify focus lines or topics, what detail levels are available, or how output_format behaves. An agent would lack essential information to call this tool correctly, making the description incomplete for a moderately complex 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%, but the descriptions are minimal (e.g., 'Code', 'Model', 'Focus lines'). The main description adds value by clarifying the focus parameters (symbol, line, topic) which aligns with focus_symbols, focus_lines, and focus_topics. However, it does not explain parameter values, formats, or how they interact. The baseline of 3 is appropriate as the description adds some but not comprehensive context.

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

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

The description clearly states the tool explains supplied source code, with a specific verb and resource. It also mentions optional focus on symbols, lines, and topics, which distinguishes it from generic analysis tools. However, it doesn't explicitly name sibling tools or contrast them, so it loses a point for lack of direct 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 provides no guidance on when to use this tool versus alternatives like coeus_analyze or coeus_review_code. It doesn't state prerequisites, when to prefer this over others, or when not to use it. This leaves the agent to infer usage from the tool name and siblings.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action without describing expected output format, error handling, limitations, or any side effects. An agent cannot anticipate how the tool responds or what constraints apply, making this a significant transparency 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 a single, front-loaded sentence that immediately states the verb and resource. It is efficient and contains no filler. While it is brief, it is a complete sentence and not a tautology, so it earns a high conciseness 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?

With no output schema and no annotations, the description is the only source of context. It fails to explain how the extraction result is returned, how to construct a valid schema, what 'examples' influence, or what 'strict mode' controls. For a tool with five parameters and no structured output definition, this is incomplete and leaves critical usage details unknown.

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 descriptions are tautological ('Model', 'Schema', 'Content', 'Examples', 'Strict mode') and add no meaning beyond parameter names. The description adds a single hint: 'using a JSON schema' clarifies that 'schema' refers to a JSON schema, but it does not explain content expectations, examples format, or strict_mode behavior. With coverage at 100% but descriptions offering little value, the description fails to compensate for the missing semantic depth.

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 ('Extract'), the resource ('structured data from content'), and the method ('using a JSON schema'). It communicates the core purpose effectively. However, it does not differentiate this from siblings like coeus_analyze or coeus_summarize, which could also process content; a brief note on when extraction is preferred over analysis would push it to 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 versus alternatives. No mention of prerequisites, exclusivity, or conditions that would make this the right choice over coeus_analyze or coeus_summarize. The agent must infer usage from the purpose alone, which is insufficient.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not state whether this tool mutates state, requires authentication, or has side effects. It also does not explain what happens after creation or how the brief is stored or returned. For a tool that creates something, this is a significant transparency 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 a single sentence with no wasted words, and it front-loads the core action ('Create a frontend design brief'). The pipeline context is useful and compact. It could be slightly more structured, but it is appropriately sized.

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

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

Given 7 parameters, no annotations, and no output schema, the description is too thin. It does not explain what the tool returns, how the brief is used downstream, or what distinguishes it from the many sibling design/review tools. An agent would struggle to know exactly what to pass and what to expect back.

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 schema already documents all 7 parameters. The description adds no parameter-level meaning beyond the schema, but the baseline of 3 applies because the schema does the heavy lifting. The description's mention of 'taste direction, components, and assets' loosely maps to some parameters but does not clarify their semantics.

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

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

The description 'Create a frontend design brief; pipeline step 1 before taste direction, components, and assets' identifies a specific verb and resource, and hints at its position in a pipeline. However, it does not clearly distinguish this from sibling tools like coeus_frontend_taste_direction or coeus_design_review_bundle, and the phrase 'pipeline step 1' is vague about what the tool actually produces.

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

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

The description implies this is the first step in a frontend design pipeline, which gives some context for when to use it. But it does not explicitly state when not to use it or name alternative tools for related tasks, such as coeus_project_intake or coeus_design_review_bundle. The guidance is implied rather than 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?

With no annotations provided, the description carries the full burden of disclosing behavior. It mentions pipeline position and the goal of being 'non-generic,' but it does not describe what the tool produces, whether it persists anything, what side effects it has, or what the returned artifact looks like.

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

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

The description is a single sentence with no filler. The core action is front-loaded, and the 'pipeline step 2 before component creation' clause adds meaningful context without increasing length unnecessarily.

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 minimally adequate: it states what the tool does and where it fits in the pipeline. However, there is no output schema and no annotation coverage, and the description does not explain what the 'taste direction' output should contain, how to interpret success, or how this step relates to the surrounding design pipeline tools.

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

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

Schema description coverage is 100%, so the parameter names and one-word descriptions already carry the semantic load. The description adds no parameter-specific detail, which is acceptable under the baseline, but it also does nothing to enrich the meager param descriptions like 'Constraints' or 'Originality targets.'

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 ('Define') and a specific resource ('frontend taste direction'), and adds pipeline context ('step 2 before component creation') that helps an agent place it in a workflow. It does not explicitly differentiate it from related siblings like coeus_frontend_design_brief or coeus_ui_asset_sources, so it falls just short of a 5.

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

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

The phrase 'pipeline step 2 before component creation' gives a clear temporal condition for when to invoke this tool. It does not name alternative tools or state when not to use it, but the pipeline sequencing provides usable 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 full burden. It says 'generate' but doesn't disclose whether this is a read-only operation, whether it calls external models, whether it has rate limits, or what the output format looks like. The include_analysis parameter hints at optional analysis, but the description doesn't explain what that means behaviorally.

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

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

The description is a single concise sentence that states the core purpose. It's front-loaded and efficient, though it could add a bit more context without becoming bloated.

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

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

With no annotations, no output schema, and 5 parameters, the description is too thin. An agent doesn't know what the generated commit messages look like, whether analysis is included by default, or how this relates to other diff-handling tools in the sibling list.

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 schema already documents all 5 parameters. The description adds no additional meaning beyond what the schema provides. 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 'Generate commit message candidates from a diff' states a specific verb and resource, and the title 'Generate commit message candidates from a diff' reinforces it. However, it doesn't distinguish this from sibling tools like coeus_review_code or coeus_git_diff_review, which could also operate on diffs.

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 about when to use this tool versus alternatives. The sibling list includes coeus_git_diff_review and coeus_review_code, which might be confused with this tool, but the description doesn't clarify the distinction.

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 to carry the behavioral burden, and the description only says it generates docs. It does not disclose what the tool returns, whether it writes files or outputs text, whether it requires any prerequisites, or how the optional parameters affect 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 a single efficient sentence with no filler or repetition. It front-loads the primary purpose and lists concrete output types, though it sacrifices useful detail for brevity.

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

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

For a tool with six optional parameters, no output schema, and no annotations, the description is too thin to fully guide an agent. Key context is missing around parameter semantics, return format, and when to choose this tool over the many related coeus_* siblings.

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 even though each parameter description is minimal. The description adds some context by enumerating doc types like README, API docs, and docstrings, but it does not clarify what 'model', 'template', or 'output_format' mean.

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 verb 'Generate' with a clear resource type: docs, README content, API docs, and docstrings for supplied code. It is specific enough to distinguish it from siblings like coeus_generate_commit and coeus_generate_tests, though it does not explicitly name any sibling alternatives.

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

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

No guidance is given about when to choose this tool over alternatives such as coeus_generate_tests, coeus_explain_code, or coeus_docs_drift_check. The description implies the use case but provides no prerequisites, exclusions, or comparison to related tools.

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

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

With no annotations, the description carries the full burden of explaining behavior, but it only states that tests are generated. It does not disclose side effects such as possible test execution (suggested by the execute_tests parameter), model usage, return behavior, or prerequisites.

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

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

The description is a single, front-loaded sentence with no wasted words. It could arguably say more about the tool's process, but what it does say earns its place.

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

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

For a tool with eight parameters, no annotations, and no output schema, this description is too thin. It does not explain key behavioral parameters like execute_tests, output_format, or test_framework, nor does it set expectations for what the agent will receive after invocation.

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

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

Schema description coverage is 100%, so the schema already documents all eight parameters by name. The description adds only the notion of 'supplied source,' which maps to the required 'code' parameter, but provides no further semantic value beyond what the schema already gives.

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 ('Generate') and the resource ('test files or test code' for 'supplied source'), so an agent can understand the core function. However, it does not differentiate itself from nearby siblings like coeus_test_strategy or coeus_review_bundle, which may equally deal with tests.

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 explicit guidance on when to use this tool versus alternatives, and no exclusions or conditions are provided. 'For supplied source' weakly implies a context, but it is not enough to help an agent choose between this and test-related sibling tools.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It does reveal the output shape ('structured findings (status/ship/findings)'), but it does not explicitly state that the tool is read-only, whether it has side effects, or how it behaves on invalid inputs. It adds some value beyond the name but leaves the safety profile 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 entire description is one efficient sentence that immediately identifies the alias, the action, the resource, and the expected output. There is no filler or redundant restatement of 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?

For a relatively simple review tool with one required parameter and no output schema, the description gives the essential invocation context. It mentions the output structure and points to the canonical coeus_review behavior via the alias. It could add more about optional parameter usage, but nothing critical is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not meaningfully enrich parameter understanding beyond the schema's terse labels ('Diff', 'Model', 'Base branch', 'Commit message'), but 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 reviews an explicit git diff and returns structured findings (status/ship/findings). It names the resource ('explicit git diff') and identifies itself as an alias of coeus_review, making its function immediately distinguishable from related review 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 phrase 'review an explicit git diff' gives clear context for when this tool applies. It does not explicitly enumerate when to avoid it or compare it to siblings like coeus_review_pr, but the 'explicit diff' framing is sufficient guidance for most agents.

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 lists what is validated but doesn't disclose what happens on failure, whether it makes network calls (the probe_network param suggests optional network probing), whether it modifies anything, or what the output looks like. The description is a static list of checked items without 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?

One sentence that front-loads the purpose and lists the checked components compactly. No wasted words, though it could be slightly more structured.

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

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

For a healthcheck tool with no annotations and no output schema, the description is thin. It doesn't explain what a successful or failed validation looks like, whether the tool is safe to run, or how the optional probe_network parameter affects behavior. An agent would need to call it to understand its 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 the schema already documents the single parameter. The description doesn't add meaning beyond the schema, but with full coverage 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 uses a clear verb ('Validate') and names the specific resources it checks: entry point, providers, keys, CLI paths, and dependencies. This distinguishes it from sibling tools like coeus_runtime_diagnostics or coeus_capabilities, though it doesn't explicitly name a sibling to differentiate from.

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

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

The description implies this is a health-check/validation tool for the Coeus environment, but it doesn't state when to use it versus alternatives like coeus_runtime_diagnostics or coeus_version. No explicit when/when-not guidance is provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that the tool returns an error if the routed model cannot emit an image, which is useful, but it omits many other behavioral aspects: it doesn't state whether the operation is read-only or mutating (though generation is typically non-destructive), doesn't describe the output format beyond 'image bytes', doesn't mention rate limits, auth requirements, or side effects. For a generation tool, this is sparse.

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

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

The description is a single sentence with no wasted words. It front-loads the core purpose ('Generate image bytes') and then adds the conditional context. It is as concise as possible while conveying the key operational constraint.

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 parameters, no output schema, and no annotations, the description is insufficient. It doesn't explain parameter behavior beyond the schema, doesn't describe the return format in detail (e.g., MIME type, encoding), doesn't provide examples or edge cases, and doesn't clarify how the tool interacts with routing. An agent would struggle to invoke it correctly for varied use cases.

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% for all 8 parameters, but the schema descriptions are terse (e.g., 'Seed', 'Model', 'Style'). The tool description adds no additional meaning to any parameter, such as clarifying what 'style' accepts or how 'aspect_ratio' should be formatted. Since the schema covers all parameters, the baseline is 3, and the description doesn't enhance it.

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 generates image bytes, with a specific verb and resource. It also adds a conditional qualifier about provider capability. However, it doesn't explicitly distinguish itself from sibling tools like coeus_pixel_art_generate, which could lead to ambiguity for an agent choosing between image generation 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 gives a condition for successful use (capable provider configured) and mentions an error case, but it provides no guidance on when to choose this tool over alternatives. It doesn't reference sibling tools or specify use cases such as 'for general images vs. pixel art'. An agent would have no clear decision criteria beyond the provider capability.

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 of behavioral disclosure. It only states the action ('List'), which implies a read-only operation, but it does not describe what the tool returns (e.g., conversation IDs, titles, timestamps), whether the list is ephemeral, or any limitations. This is minimal disclosure for a tool that could have side effects or specific output 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, focused phrase with no redundant wording. It is front-loaded with the essential action and resource. While it is brief, it is appropriately sized for a simple tool, though the brevity contributes to incompleteness elsewhere.

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 no output schema, the description should compensate by indicating what the response contains. It does not mention return fields, what 'active' means, or whether results are sorted or paginated. The agent is left with minimal guidance on how to interpret the output, making this incomplete for even a simple listing 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% because the single parameter 'limit' has a description ('Limit'), but that description is vague and does not clarify the meaning (e.g., maximum number of results, pagination). The tool description adds nothing beyond the schema, so the baseline of 3 applies, but it does not enhance the semantics.

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

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

States a specific verb ('List') and a precise resource ('active in-memory conversations'), which clearly distinguishes it from conversation-related siblings like coeus_start_conversation, coeus_continue_conversation, and coeus_clear_conversation. The 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 implies usage (if you want to see active conversations, call this tool), but it does not explicitly state when to use it versus alternatives, nor does it mention any exclusions or prerequisites. The context is clear enough for a simple listing operation, but there is no explicit guidance about when not to use it.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only states that the tool returns inventory; it does not mention whether it is read-only, accesses network resources, can be slow, or what failure modes exist. For a zero-parameter tool this is a lesser gap, but still significant with no annotation support.

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 waste. Every word adds meaning, and it is immediately clear what the tool does. This is an exemplary use of brevity for a simple 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 parameterless, schema-less tool, the description covers the core purpose adequately. However, with no output schema or annotations, it would benefit from a brief note on return format or source of 'authoritative' data. The missing behavioral details (e.g., read-only guarantee) also reduce completeness, but the simplicity of the tool partially offsets this.

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 schema coverage is trivially 100% and the baseline is 4. The description adds no parameter-specific meaning because there are none, but also does not need to. It appropriately clarifies the resource being returned.

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 verb ('Return') and resource ('authoritative model inventory for each configured provider'). It is distinct from many siblings by focusing on model inventory, but it does not explicitly differentiate itself from similar listing/introspection tools like coeus_capabilities or coeus_healthcheck.

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 about when to use this tool versus alternatives. There is no mention of prerequisites, typical use cases, or exclusions. An agent must infer when this is the right tool from the name and description alone.

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 behavioral burden. It does disclose that verification is 'real' (actual provider execution) and that output is a consensus summary, but it omits side effects such as network/provider calls, potential cost, failure modes, or what 'consensus limits' means in practice.

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 filler. It wastes no words and immediately communicates the core purpose and distinguishing trait of the tool.

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

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

For an 8-parameter tool with no output schema and no annotations, a one-line description is insufficient. It leaves unclear what inputs are expected beyond 'prompt', what 'configured providers' refers to, how 'consensus limits' are computed, and what the result looks like.

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 no parameter-specific meaning beyond the schema's terse labels like 'Models', 'Providers', and 'Reasoning'; it does not clarify formats, constraints, or how parameters interact.

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

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

The description is specific: it names the action ('Run real verification'), the resource ('across configured providers'), and the expected outcome ('summarize consensus limits'). This distinguishes it from siblings like coeus_verify_solution and coeus_second_opinion by emphasizing multi-provider, consensus-focused execution.

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 about when to use this tool versus alternatives like coeus_verify_solution, coeus_second_opinion, or coeus_critical_debate. No conditions, prerequisites, or exclusions are provided, so the agent must infer when this multi-provider verification path is appropriate.

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

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

No annotations are present, so the description carries the full burden of disclosing behavior. It states the action and operations but does not explain side effects, whether regeneration modifies the grid in place, how the style contract is applied, or how candidate_count affects the result.

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 names the resource and both supported modes without filler. It is concise and easy to parse, even if it sacrifices 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 no output schema, seven parameters, and no annotations, the description leaves important context unexplained: grid format, role of palette/ramp, semantics of candidate_count, and expected result format. The existing sentence is too thin for safe invocation.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the parameter descriptions are tautological ('Grid', 'Style', 'Op'). The description adds the useful 'style contract' framing but does not clarify formats, relationships between grid, ramp, palette, and style.

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 names a specific verb ('Edit') and resource ('pixel grid'), and explicitly lists the two supported operations ('recolor' or 'regenerate_slot'). It is more informative than a bare restatement, though it does not explicitly contrast itself with sibling tools like coeus_pixel_art_set or coeus_pixel_art_generate.

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 choose edit versus alternative pixel-art tools or when recolor is appropriate versus regenerate_slot. The phrase 'under a style contract' hints at a constraint, but provides no decision-relevant context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'allowed source families' but does not define what those are, whether the tool performs external network calls, whether it is read-only, or any rate limits or authentication requirements. The phrase 'allowed' implies restrictions but leaves their nature entirely unspecified.

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

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

The description is a single short sentence that front-loads the core action and scope. It is efficient with no fluff. However, it is so terse that it omits necessary details, which prevents a perfect score for structure.

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 6 parameters, no output schema, and no annotations, the description is severely under-specified. It does not explain allowed source families, accepted parameter values, output format, pagination, or error behavior. An agent cannot reliably craft a valid query or interpret the result set based solely on the provided information.

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

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

Although schema description coverage is 100%, the schema descriptions are single-word placeholders ('Model', 'Query', 'Sources', etc.) with no explanatory value. The tool description adds only a loose connection between 'source families' and the `sources` parameter, but does not clarify values for `sprite_type`, `license_filter`, `max_results`, or `model`. This fails to compensate for the shallow schema descriptions.

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

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

The description states a specific verb ('Find'), a resource ('pixel-art references or sprites'), and a scoping constraint ('from allowed source families'). This distinguishes it from the pixel_art_generate/set/edit siblings by implying a search operation. However, 'allowed source families' is vague and the description does not explicitly name any sibling to differentiate from, so it misses the top score.

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

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

The description provides no guidance on when to use this tool versus alternatives like coeus_pixel_art_generate or coeus_web_search. It does not state any conditions, prerequisites, or when NOT to use it. The only implication is that it is for finding pixel-art references, but no explicit context or exclusion 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?

No annotations are provided, so the description must fully disclose behavior. It only mentions 'generate', which implies a crative action but doesn't specify side effects, return format, or any constraints. The agent cannot infer whether this is a safe read operation or a mutation.

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

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

The description is a single short sentence, which is concise and front-loaded, but it sacrifices essential detail. It doesn't structure information or hint at parameters, output options, or typical use. It's concise but under-specified.

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 10 parameters, no annotations, and no output schema, the description is critically incomplete. It fails to mention supported output formats, candidate counts, palettes, or any behavioral nuances. An agent cannot safely invoke this tool with just the schema and this description.

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

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

Schema description coverage is 100%, so parameters have at least minimal descriptions (e.g., 'Prompt', 'Width'). The tool description adds no extra meaning beyond the schema, so a baseline 3 is appropriate. It doesn't clarify how parameters interact or what defaults mean in context.

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

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

The description states a clear verb ('Generate') and resource ('pixel-art sprite plans and renderable pixel grids'), which distinguishes it from sibling tools like edit/find/set. However, it doesn't explicitly name those alternatives or elaborate on the 'plans' aspect, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus pixel_art_edit, pixel_art_set, or other generation tools. No context, prerequisites, or exclusions are provided, leaving the agent to guess.

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 disclosing behavioral traits such as side effects, return shape, or failure behavior. It only says the tool generates an icon family and does not explain how allow_partial, candidate_count, or palette affect the result.

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 one sentence with no filler, front-loading the verb and the expected outcome. Every word earns its place, and the structure is easy for an agent to parse quickly.

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

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

With six parameters, no annotations, and no output schema, a one-line description is not enough. An agent still needs to infer how candidate_count and allow_partial change behavior, what a generated family looks like, and whether the operation has side effects or prerequisites.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters. The description adds only a light semantic link between 'names and a shared prompt' and the names/prompt parameters, without enriching width, palette, allow_partial, or candidate_count.

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 action ('Generate') and a concrete deliverable ('matching UI icon family') and identifies the core inputs ('names and a shared prompt'). This distinguishes it from pixel-art siblings such as pixel_art_edit and pixel_art_find, though it does not explicitly name alternative siblings.

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

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

The description implies when to use the tool: when multiple icons should be produced from a given set of names and a shared prompt. However, it offers no explicit when-not guidance and does not name alternatives like coeus_pixel_art_generate, leaving usage routing mostly to inference.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies read-only operations ('list or inspect') but doesn't explicitly state that it has no side effects or that it requires no special permissions. Given the simplicity, the description is adequate but not rich in 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 a single, front-loaded sentence with zero waste. It efficiently conveys the tool's purpose without any redundant phrasing.

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

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

Given the tool's low complexity (one optional parameter, no output schema), the description is reasonably complete. It doesn't specify the return format, but with no output schema, that may be acceptable. It also doesn't mention error handling or prerequisites, but for a simple list/inspect utility, these are minor gaps.

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

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

Schema coverage is 100%, so the parameter 'name' is documented. The description adds meaning by indicating that providing 'name' inspects a specific palette while omitting it lists all, which goes beyond the schema's simple 'Name' description. This clarifies the parameter's conditional role.

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: 'List or inspect bundled pixel-art palettes'. It identifies the resource (bundled pixel-art palettes) and the actions (list or inspect), making it distinguishable from sibling pixel-art tools like generate, set, edit, and find. However, it doesn't explicitly name a specific sibling or contrast itself, so a slight deduction from a perfect score.

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

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

There is no guidance on when to use this tool versus alternatives. It doesn't mention scenarios where this tool is preferred over other pixel-art tools, nor does it exclude cases. The description simply states what it does without context on selection.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only says 'map' without indicating whether the operation is read-only, whether it modifies the repository, if it has side effects, or what the output format is. This is a significant gap for an agent deciding whether to invoke the tool.

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

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

The description is a single, concise sentence with no wasted words. However, it lacks structure and important context such as output details or usage scenarios. While it is not verbose, it is under-specified, which is a different issue from conciseness.

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

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

Given the tool has 3 optional parameters and no output schema, the description should explain what the tool returns, any prerequisites, and how to interpret the results. It does not. The description is extremely sparse and fails to provide enough context for an agent to use the tool effectively.

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

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

Schema coverage is 100%, as each parameter has a brief description ('Root', 'Max depth', 'Max files'). The tool description adds no additional semantics about these parameters, but since the schema already documents them, the baseline of 3 is appropriate. The parameter descriptions are minimal, so the tool description could have elaborated but chose not to.

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: mapping a repository's stack, risks, key files, and suggested workflows. However, it does not distinguish itself from similar siblings like coeus_codebase_map or coeus_analyze_codebase, which may also map repository aspects, so it is not fully differentiated.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any exclusions, prerequisites, or specific scenarios where this tool is preferred over other analysis tools, leaving the agent to guess.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Convert...' without mentioning whether this is a read-only operation, what side effects exist, whether external calls are made, or what the output format looks like. This is a significant gap for a tool that likely produces a plan artifact.

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

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

The description is a single, concise sentence that front-loads the core purpose. It avoids redundancy but is perhaps too terse to convey sufficient context for a 5-parameter tool. Still, for conciseness alone it earns a strong 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's complexity (5 parameters, no output schema, no annotations), the description is incomplete. It does not explain the output structure, how parameters interact, or any usage nuances. An agent would need to infer most details from the parameter names alone, which is insufficient for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3. However, the schema's parameter descriptions are tautological (e.g., 'Model', 'Tasks') and the tool description adds no clarification about expected formats, relationships, or usage of each parameter. It only mentions 'project goals and tasks' but does not explain 'constraints' or 'context'.

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

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

The description states a specific action ('Convert... into an ordered implementation plan') with a clear resource and output. It is distinguishable from many siblings by the 'ordered plan' focus, though it does not explicitly differentiate from other planning tools like coeus_eval_plan or coeus_workflow_automation_plan.

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 the many sibling planning tools. There is no mention of prerequisites, typical use cases, or when to avoid it. The description only states what it does, not when to apply 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, so the description carries the full burden of behavioral disclosure. It does not state whether the tool returns suggestions, rewrites code, writes files, requires specific permissions, or otherwise behaves beyond 'suggest or generate refactors.'

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

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

The description is a single concise sentence that front-loads the core action and resource. It contains no filler, though it is terse enough that some important contextual information is absent.

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 six parameters, no output schema, no annotations, and many sibling tools, this description is too thin for reliable invocation. An agent would not know what values to supply for goal, language, output_format, or refactor_type, nor what the tool returns.

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 even though the parameter descriptions are tautological ('Code', 'Goal', 'Model'). The tool description adds almost no meaning to the parameters and does not clarify valid values for goal, model, language, output_format, or refactor_type.

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

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

The description states a clear action ('Suggest or generate refactors') and a specific resource ('supplied source code'), which makes the tool's core function understandable. It is distinct enough from siblings like coeus_review_code or coeus_explain_code because it centers on refactoring, though it does not explicitly call out those differences.

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

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

There is no guidance on when to use this tool versus alternatives. The description never mentions when refactoring is preferred over reviewing, explaining, or analyzing code, and it provides no exclusions or preconditions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the output type (checklist) but does not mention whether the tool performs side effects, requires specific permissions, or how it gathers information (e.g., git status, target context). The description is too thin to convey behavioral expectations for an agent.

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

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

The description is a single sentence that is concise and front-loaded with the core purpose. There is no wasted wording, and the message is delivered immediately.

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, no annotations, and only two optional parameters. The description provides minimal context about what the checklist contains, what inputs are used for, or when to invoke it. An agent would need additional context to know if this is the right tool for a given task, and the absence of behavioral or usage guidance makes it 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 description coverage is 100%, with both parameters ('target' and 'include_git_status') having descriptions in the schema. The description itself adds no additional meaning about parameters, but the baseline of 3 applies because the schema already documents them sufficiently.

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

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

The description states a clear action: 'Return a ship/no-ship release readiness checklist'. This conveys the tool's purpose precisely with a specific verb and resource. It doesn't explicitly differentiate from sibling tools, but the purpose is unambiguous enough to be understood without comparing to others.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention any prerequisites, conditions, or scenarios where this tool is preferred over other sibling tools like coeus_review_bundle or coeus_healthcheck. The agent is left to infer usage context.

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

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

With no annotations, the description carries the full behavioral burden and does disclose the finder-then-verify pipeline and JSON findings output. However, it does not mention side effects, input relationships, preview behavior, or what happens with finder/verifier model selection.

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

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

Two short, front-loaded sentences with no filler; the description is immediately usable as a quick orientation. The effort enum restated in the schema is redundantly summarized in one clear phrase.

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 13 parameters, no annotations, and no output schema, one sentence is insufficient guidance for correct invocation. Missing context includes how code/diff/context/repository_path relate, what preview_only controls, what the findings JSON structure is, and how this tool differs from its many review siblings.

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 even though the description mostly restates parameter names like 'Code', 'Diff', and 'Effort'. The description adds only the effort enum values, which are already present in the schema, and adds no new meaning about how the 13 parameters interact.

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 structured finder-then-verify code review and that it returns findings JSON, so the core action and output are understandable. However, it does not distinguish this tool from the many sibling review tools such as coeus_review_code, coeus_git_diff_review, or coeus_review_pr.

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 phrase 'code review' implies when the tool is relevant, and the effort levels signal depth, but there is no explicit guidance about when to choose this tool over alternatives. No exclusions or comparisons to sibling review tools are provided.

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 behavioral disclosure burden. It does disclose that the tool returns structured findings and that preview_only avoids calling the provider, which is meaningful. However, it does not describe side effects, requirements, or what 'structured findings' contain.

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 compact and front-loads the core behavior before the preview_only caveat. The phrase 'Alias of coeus_review' adds marginal value but is not bloated. Every other part 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?

With 7 optional parameters, no output schema, and no annotations, this description is too thin for an agent to invoke the tool confidently. It does not explain the expected structured findings shape, the route object, or when preview_only should be set. The alias reference does not compensate for these gaps.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the parameter descriptions are just one-word labels. The description adds a little by grouping diff/code/context as the bundled review inputs and explaining preview_only's effect. It does not clarify focus defaults, provider/model behavior, or how the inputs interact.

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

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

The description states a clear action and scope: bundle diff/code/context review and return structured findings. The phrase 'Alias of coeus_review' adds some confusion, but the rest makes the tool's purpose understandable. It does not differentiate from siblings like coeus_review or coeus_git_diff_review, which keeps it from 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 explicit guidance on when to use this tool versus coeus_review, coeus_review_code, or coeus_git_diff_review. The preview_only note describes a mode, not a usage context. The alias statement implies interchangeability but never states when that is appropriate.

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

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

No annotations are provided, so the description must carry the full burden. It does not disclose whether the operation is read-only, what the output looks like, how severity thresholds affect results, or any side effects. It adds minimal behavioral context 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, concise sentence that states the action and scope. There is no redundancy or filler. It is appropriately front-loaded with the core function.

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

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

For a tool with 7 parameters, no output schema, and no annotations, the description is insufficient. It does not explain what the output will be (report, format), how focus_areas or severity_threshold work, or how this differs from other review tools. The agent would need to infer too much.

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 having a description. The tool description does not elaborate on parameter meaning, but the schema already provides basic descriptions. The description mentions 'requested severity/output constraints' which loosely maps to the severity_threshold and output_format parameters, but adds no new detail 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's action ('Review') on a specific resource ('a code blob') and lists the aspects it evaluates (quality, security, performance). It distinguishes itself from siblings like coeus_git_diff_review (diffs) and coeus_review_pr (PRs) by specifying 'code blob', though it does not explicitly name alternatives.

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 coeus_review or coeus_analyze. It does not mention prerequisites, exclusions, or preferred contexts, leaving the agent to infer.

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 only states the tool 'gathers a diff and returns findings', which implies a read operation but does not mention whether it modifies anything, requires network access, or any side effects. Critical gaps for an agent assessing safety and 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, concise sentence that front-loads the core purpose. It has no fluff, but is arguably too brief to be fully useful; however, for conciseness it earns 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?

With 7 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain which parameters are required for different scenarios (e.g., PR vs diff range), what 'structured findings' means in terms of output format, or any operational constraints. An agent would lack critical information 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 schema already documents all parameters, though very tersely (e.g., 'Diff', 'Model'). The description adds no additional meaning beyond what the schema provides, 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 gathers a PR or base..head diff and returns structured findings. It identifies itself as an alias of coeus_review, which makes the purpose explicit, though it does not differentiate itself from similar review siblings like coeus_git_diff_review or coeus_review_code.

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

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

The description implies usage for PR review by mentioning PR and base..head diff, but does not provide explicit when-to-use vs alternatives or exclusions. It only notes it's an alias, which gives some context but no actionable guidance on when to prefer this tool over 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 provided, the description carries the full burden of disclosing behavior. It only says 'choose' without explaining side effects such as whether it invokes external APIs, costs money, overrides user-specified parameters, or how the 'auto' provider behaves. It does not mention what the output looks like or whether it is deterministic. This is a significant gap for a tool with many parameters and no annotation support.

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, well-structured sentence that front-loads the core action and key decision factors. It contains zero waste and is easily scannable, making it highly efficient for an agent 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?

Given 12 parameters, 100% schema coverage, no output schema, and no annotations, the description is too thin. It does not explain the tool's return value (e.g., whether it returns a routing decision, a message, or an error), how the 'auto' provider selection works, or the meaning of 'workflow.' For a complex routing tool, the description should provide more context about expected behavior and outcomes, but it leaves many critical details unexplained.

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 12 parameters are already documented in the schema. The description adds minimal value by referencing 'task, budget, speed, and vision needs,' which map to a few parameters but does not explain their interplay or provide syntax beyond the schema. Per the baseline, a score of 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 states a clear purpose: it selects provider, model, and workflow based on task, budget, speed, and vision needs. The verb 'choose' and the resource ('provider, model, workflow') are specific. However, it does not explicitly distinguish itself from the many sibling tools that also handle specific tasks (e.g., coeus_analyze, coeus_summarize), so an agent might not know whether to route through this or call a specialized tool directly.

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

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

The description implies when to use it: when you have task, budget, speed, and vision needs to consider. This gives context but does not state explicit exclusions or alternatives. It does not say 'use this when you need automatic model selection' or 'for simple tasks, use a dedicated tool instead.' The guidance is implicit rather than explicit, so it is average.

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 mentions 'secret-safe' as a safety property but does not state whether the tool is read-only, what side effects the network probe may have, or any permission requirements. This is a significant gap for a diagnostic tool.

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

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

The description is a single, efficient sentence that front-loads the action and scope. Every word contributes to the purpose, and there is no fluff or redundant 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?

The description is too vague for a tool with no output schema and no annotations. It does not specify the format or content of the returned diagnostics, nor does it clarify how this differs from coeus_healthcheck. An agent cannot fully assess whether this tool meets its needs or how to interpret the result.

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 the only parameter (probe_network) with a minimal description 'Probe network', but the tool description adds no additional meaning. Since schema coverage is 100%, the baseline is 3, and the description does not enhance understanding of the parameter's purpose or effect.

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 verb ('Return') and a resource ('runtime, CLI, git, catalog, and provider readiness diagnostics'), which distinguishes it from siblings like coeus_healthcheck or coeus_stats. However, it could be more explicit about what 'readiness diagnostics' actually entails, leaving some ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any context, prerequisites, or exclusions, leaving the agent to infer when it should be selected over other diagnostic tools like coeus_healthcheck.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits, but it only adds the vague qualifier 'rigorous'. It does not explain whether this invokes another model, how reasoning is controlled, what the output looks like, or whether any state changes occur.

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 filler. It is efficient, though slightly underspecified for a tool with five parameters and no other explanatory material.

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 moderate complexity, overlapping siblings, and absence of an output schema or annotations, the description is incomplete. It does not clarify expected input semantics, model selection behavior, reasoning modes, or what constitutes a useful second opinion 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 already covers all parameters with descriptions, even though those descriptions are just the parameter names. The tool description adds no further meaning about how parameters like 'context', 'approach', and 'question' interact, so the baseline 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 clearly states the tool's function: providing a rigorous second opinion on an approach or technical decision. It is not a tautology and conveys a distinct purpose, though it does not explicitly differentiate itself from overlapping siblings such as coeus_critical_debate, coeus_counterfactual_review, or coeus_multi_model_verify.

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 phrase 'second opinion' implies when to use the tool, and the required 'context' and 'approach' parameters reinforce that. However, it provides no explicit guidance on when not to use it or which sibling tool would be preferable for related but different needs.

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. The term 'in-memory' hints at non-persistence, but nothing is disclosed about session lifetime, whether a start discards prior sessions, whether multiple sessions can coexist, or what the return value is. For a tool that creates a session, these are significant undocumented behaviors.

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

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

The description is a single efficient sentence with no wasted words, which is good for conciseness. However, the brevity borders on under-specification for a tool with three parameters and no output schema. It is appropriately short but does not earn its length with substantive 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?

For a tool that initiates a session, the description is incomplete. It does not address how 'in-memory' affects conversation persistence, how a new session relates to existing ones, or how it interacts with the sibling conversation tools. With no output schema and no annotations, an agent lacks essential context to call this 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%, which establishes a baseline of 3. However, the schema descriptions are bare labels ('Title', 'Description', 'Tags') that add little semantic meaning. The tool description contributes nothing about the parameters beyond what the schema states, so it does not exceed the baseline, though it does not fall below it either.

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 verb ('start') and resource ('conversation session'), but this is nearly a restatement of the tool name 'start_conversation'. The only added information is 'in-memory', which provides a slight qualifier. It does not distinguish the tool from its conversation siblings like continue_conversation, list_conversations, or clear_conversation, so it falls short of clear 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?

No usage guidance is provided. The description does not mention when to use this tool versus alternatives, nor does it state any conditions for starting a conversation. Given the presence of closely related siblings (continue_conversation, list_conversations, clear_conversation), the absence of any routing or when-to-use guidance is a notable gap.

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

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

With no annotations provided, the description must disclose behavioral traits. It only says 'plan', implying a read-only analysis, but does not explicitly state that it makes no changes, requires no auth, or has any side effects. The lack of explicit safety or side-effect disclosure is a gap for a tool without 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 a single, efficient sentence that front-loads the core purpose and includes the pipeline step context. No filler words or redundant details.

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

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

The tool has five parameters, two required, no output schema, and no annotations. The description provides only the high-level purpose and pipeline position, leaving out how the parameters relate to the 'safe' planning process, what constitutes a safe integration, or what the expected output is. This is insufficient for a tool with moderate complexity and no other documentation.

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 already documented. The description adds no extra meaning to the parameters, such as their roles or relationships, which is acceptable given the high schema coverage but does not enhance semantics.

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

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

The description clearly states the action ('Plan safe static asset integration') and the input ('sourced asset manifest'), and adds a pipeline context ('step 5'). It is distinct from other planning tools by focusing on static assets, though it doesn't explicitly name alternatives.

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 'pipeline step 5' hint gives some positional context, but there is no explicit guidance on when to use this tool over siblings like coeus_eval_plan or coeus_project_task_plan, nor any exclusions or prerequisites.

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 disclosure burden, but the single sentence only states what the tool returns. It does not disclose side effects, read-only behavior, server access, rate-limit implications, or response format, leaving an agent to infer that a stats call is safe. The implied read-only nature adds a little context, but not enough to exceed a 2.

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 filler or repetition, and it contains the essential resource scope in its first few words while remaining appropriately sized for a simple one-parameter read tool. The terseness is genuine conciseness, not under-specification, since the management of the single-enum parameter sits in the schema as it should. It holds to a 4 because the price of that brevity is the missing behavioral context and section detail not reflected in the dimension.

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 (one optional enum parameter) the description plus schema make a basic call complete, but the missing output schema and the absence of annotations raise the burden for return values, units, and any quirks, none of which are described. The agent can probably invoke it correctly but cannot know what a full response looks like, making this a minimum-viable 3.

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 covers the only parameter, reporting 100% schema_description_coverage, so the baseline is 3 and the tool description adds nothing parameter-specific beyond mapping the enum values ('coeus', 'cache', 'rate') to the resource domains named in the sentence. The schema's own parameter description 'Section' is tautological, but the enum meaning otherwise falls back to the tool description's resource list. This matches the high-coverage baseline of 3.

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 plus a precise resource: 'Return consolidated Coeus server, cache, and rate-limit statistics. The enumerated resource scope (server, cache, rate-limit) makes the tool's purpose fairly distinct from sibling tools like coeus_healthcheck or coeus_version, but it never explicitly names or contrasts those siblings. This is clear but without explicit sibling differentiation, so a 4.

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?

Dimensional coverage provides zero context for when to use this tool over alternatives such as coeus_healthcheck, coeus_runtime_diagnostics, or coeus_capabilities with no exclusions, prerequisites, or conditional guidance. An agent receives no help choosing between the statistics tool and the diagnostics tools. That gap puts it at no guidance more than no guidance exists, scoring a 2.

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, and it does disclose a real behavioral nuance: files is used instead of content when both are provided. However, it does not state whether the operation is read-only, what happens when neither input is supplied, or what the output format is. The precedence disclosure makes it more than a tautology but leaves significant behavior unexplained.

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?

One sentence with no filler, and the most decision-relevant behavior is placed in the second clause. Minor pronoun ambiguity in 'it is used instead of content' and the lack of any parameter details prevent a perfect score, but the description is efficiently compact.

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

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

With no annotations, no output schema, and four optional parameters, critical call-time questions are left unanswered: what happens if both content and files are omitted, what focus means, what model values are acceptable, and what the summarized result looks like. The precedence rule helps, but the definition is too thin for an agent to invoke confidently.

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, and the description adds meaningful semantic value by clarifying that files overrides content. It also interprets files as 'file references', which goes beyond the schema's bare 'Files' label. Focus and model remain unexplained, but the key relationship between content and files is usefully documented.

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

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

States a clear verb ('Summarize') and a specific resource ('content or file references'), making the primary action immediately legible. It does not explicitly differentiate itself from sibling analysis tools, 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?

No guidance is provided for when to choose this tool over alternatives. The only conditional note is the files-vs-content precedence, which is parameter behavior rather than tool-selection context. Among many sibling tools, there is no exclusion or alternative recommendation.

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

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

With no annotations provided, the description must fully disclose behavior, but it only states the action ('create a test plan') without explaining side effects, required inputs, or output format. This is a significant gap for a tool that likely involves planning and may interact with external systems; the description provides minimal behavioral insight.

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