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

Description says 'This changes nothing in SkeletIQ — an agent never writes back to a design,' which directly conflicts with the annotation readOnlyHint=false. The annotation implies the tool may mutate state; the description claims it does not. This is a clear annotation contradiction, so the score must be 1.

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

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

The description is two sentences with no filler. It front-loads the purpose and outcome, then adds the critical covers nuance and the no-writes clarification. Every sentence 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 a full input schema, output schema, and annotations, the description covers the essential concept of drift, the covers behavior, and the side-effect guarantee. It is complete for invocation. The annotation contradiction slightly undermines the side-effect clarity, but the description itself is adequate.

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 description is not required to repeat parameter meanings. The main description adds a useful covers rule ('Declare covers when this repository implements only part of the design'), but that guidance is also present in the schema's covers parameter description. The description does not add significant meaning beyond the schema.

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

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

The description states a specific verb ('check drift') and clearly describes the resource (SkeletIQ project design/code comparison) and the three kinds of results returned: missing, half-done, and code-only. It is immediately distinguishable from siblings like list_projects, get_design, and generate_architecture.

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 context is implied: use this after building components to report progress and see drift. However, no explicit when-to-use or exclusions are given, and no alternative tools are named. An agent must infer the right timing and when not to use this tool.

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

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

The description adds meaningful behavior beyond the annotations: 'Deterministic and free — no model call, no credits, nothing stored.' This clarifies side effects, cost, persistence, and repeatability, which is especially valuable for a read-only, idempotent tool.

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

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

Three short sentences with no filler. The core action comes first, followed by key behavioral traits and a use-case tip. Every sentence earns its place.

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

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

The description, rich schema, annotations, and output schema together give the agent enough to use the tool correctly. A minor gap is that no top-level parameter is marked required, so the description could more explicitly signal that architecture_json is essential for a meaningful check.

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 tool description itself doesn't add parameter-level meaning, but the detailed property descriptions already explain domain, exposure, architecture_json, and secondary_domains thoroughly.

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

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

The description states a specific verb and resource: 'Check a design against SkeletIQ's architecture rules and get scored findings back.' This clearly differentiates it from siblings like generate_architecture or check_drift, which create or compare rather than score a design against rules.

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 clear usage context: 'Useful on a design you drafted yourself before committing to it.' It doesn't explicitly mention when not to use it or name alternative tools, so it falls just short of full 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?

Beyond the annotations, the description discloses meaningful behavior: it spends the account holder's credits, takes several minutes, uses the account holder's stored model setting rather than letting the caller choose, and returns clarification_required when the prompt names no system. It also makes clear that omitted prompt details are assumed, which is important 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 compact and front-loaded with purpose, then critical warnings about cost and latency, then behavioral context about model selection and prompt assumptions. Every sentence carries necessary information without redundancy or fluff.

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

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

Given the rich input schema, output schema, and related tools, the description covers the essential operational aspects: cost, latency, non-speculative calling, routing to get_design, model selection, assumption behavior, and clarification responses. Nothing critical for correct invocation is missing; return-value details are already covered by the output schema.

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

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

The schema already documents all parameters (100% coverage), so the baseline is 3. The description adds value beyond the schema by explaining how to write the prompt field—describe the system, its purpose, scale, and constraints—and by warning that unspecified details are assumed. This meaningfully enriches the most important parameter.

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

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

The first sentence states a specific verb+resource: 'Design a system architecture from a prompt.' It also distinguishes itself from get_design by saying existing designs should be read rather than regenerated, which differentiates it from its closest sibling.

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

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

The description explicitly warns not to call speculatively because it spends credits and takes minutes, and names get_design as the alternative when a design already exists. It also tells the caller what to include in the prompt and how the tool responds when no system is named, giving clear conditions for use.

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

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

Beyond the annotations (readOnly, idempotent, openWorld), the description reveals useful behavior: 'brief' returns a fenced markdown block for AGENTS.md, and every answer states which version it came from and whether that version is a release. This adds meaningful runtime context without contradicting the annotations.

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

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

Three sentences, all purposeful: the first states the tool's purpose, the second provides a practical usage sequence, and the third discloses a key output behavior. There is no fluff, and the most actionable guidance is front-loaded.

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

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

Given the rich input schema, annotations, and output schema, the description is largely complete: it explains the primary mode flow and a notable version-related behavior. It does not need to enumerate every mode because the schema already does that in detail.

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 all parameters with 100% coverage, so the baseline is 3. The description adds extra meaning by explaining how to sequence modes and clarifying that the version/release context appears in every answer, which goes slightly beyond what the schema states.

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

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

The description opens with a specific verb and resource: 'Read a SkeletIQ architecture.' It clearly distinguishes this tool from siblings like generate_architecture or critique_architecture by framing it as a read operation, and it adds the key concept of versioned design output.

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

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

The description gives explicit in-tool workflow guidance: start with mode 'brief' to orient, then use 'build_order' and 'component' as you build. It does not explicitly contrast this tool with sibling alternatives, but the reading workflow is clear enough to guide invocation.

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 already declare the tool read-only, idempotent, and open-world. The description adds workflow context: it is a status checker for async jobs and it hands off to get_design upon completion. This goes beyond the annotations, though it does not describe status values beyond 'completed'.

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

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

Two sentences with no filler; the trigger condition is front-loaded and the follow-up action is stated in the second sentence. 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 simple status-check tool with a full output schema and read-only/idempotent annotations, the description covers when to call it and what to do next. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, and the job_id parameter is already documented as the value returned by generate_architecture with wait: false. The description adds no new parameter semantics, so baseline 3 applies.

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

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

States a specific action ('check') on a clearly scoped resource ('background generation started with wait: false') and distinguishes it from get_design, which reads the completed result. The title reinforces that it covers queued generations, so an agent can tell it apart without opening the schema.

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

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

Gives the exact context for use (background generation with wait: false) and explicitly directs the agent to get_design when status is 'completed'. It does not enumerate exclusions, such as synchronous wait:true usage, but the context is unambiguous for this polling scenario.

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 already communicate read-only, open-world, and idempotent behavior, and the description adds useful context beyond those hints: token-scoped visibility, optional filtering, and the multiple-match 'ask, don't pick' policy. There is no contradiction with the annotations.

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

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

Three short sentences deliver the core operation, the primary use case, and the ambiguity rule with no filler. The most important 'list projects' statement is front-loaded.

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

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

With one optional parameter, full schema parameter coverage, an output schema, and annotations covering side-effect safety, the remaining agent-facing context is exactly what the description provides: token scope, filtering, and multiple-match handling. 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?

The schema already documents the only parameter fully: 'Filter by name or description. Omit to list everything the token can see.' The description repeats the optional-filter idea without adding new syntax, defaults, or examples, so it earns the baseline for full schema coverage.

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

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

The description uses a specific verb and resource: 'List the SkeletIQ projects this token can see' with optional name filtering. It also states the intended use, resolving a named project to an id, which clearly separates it from the design, generation, and critique 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?

It explicitly says 'Use this first' when a project name needs to become an id, and it gives a concrete decision rule: if multiple projects match, ask rather than pick. Since none of the siblings are list operations, no alternative routing is needed.

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