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

With annotations already declaring readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, the description reinforces 'Read-only, zero-auth, no external side effects', which is consistent and useful. It also discloses the output verdict shape (MATCH, DRIFT, UNVERIFIABLE), adding behavioral context beyond the annotations, though it doesn't explain what those verdicts mean or how the checks are scoped (which HTML surfaces, how reduced-motion is evaluated).

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 tight sentences: trigger, behavior/auth, and return shape. Front-loaded with the 'when to use' clause and no 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 zero-parameter, no-output-schema tool with strong annotations, the description covers the essentials: trigger, safety profile, and verdict values. However, the three verdicts (MATCH/DRIFT/UNVERIFIABLE) are named without definition, and the scope of 'static HTML ... Telos Studio surfaces' is vague, so an agent doesn't know exactly what gets inspected or how to interpret results.

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

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

The tool takes zero parameters (100% schema description coverage, empty properties), so the baseline is 4. There are no parameter semantics to document, and the description correctly does not invent any.

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 purpose: producing static HTML accessibility, reduced-motion, keyboard, and canvas-fallback receipts for Telos Studio surfaces. This is clearer than a generic 'check accessibility', but the unusual 'receipts' terminology and lack of explicit distinction from sibling doctors (telos.doctor, telos.presentation.doctor, telos.compatibility.doctor) reduce clarity for an agent scanning across ~40 sibling tools.

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

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

The description gives a trigger condition: 'Use when a host needs static HTML accessibility, reduced-motion, keyboard, and canvas-fallback receipts'. That implies when to use it, but no exclusions, prerequisites, or named alternatives among the many sibling *.doctor / *.proof tools are provided, leaving the agent to infer routing.

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 readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered structurally. The description adds 'zero-auth' and 'no external side effects', which is genuine extra context, but says nothing about what the returned receipt interface contains.

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, front-loaded with usage and followed by behavioral constraints. No padding, though the opening sentence is dense with undefined terms.

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 zero parameters, no output schema, and no nested objects, the tool is simple, but the description never explains the shape or meaning of the 'action-receipt interface' it returns. For a tool whose whole value is a returned record, that is a real gap an agent cannot close elsewhere.

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 takes zero parameters, so per the rubric the baseline is 4. There is nothing for the description to disambiguate beyond confirming the call takes no arguments.

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 resource ('action-receipt interface') and states it returns JSON, but offers no concrete verb or operational definition of what a receipt is or what calling the tool does. The lifecycle vocabulary ('proposed action, admission, execution, review, compensation') is domain jargon that does not clearly differentiate this tool from the ~40 telos 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?

'Use when modeling proposed action, admission, execution, review, and compensation records' gives an implied usage context, but names no alternatives, prerequisites, or when-not-to-use conditions among a very large sibling set. The guidance is abstract rather than routing.

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 readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description mostly restates those ('Read-only... no external side effects') and only adds 'zero-auth' plus the return type; with annotations in place a 3 is appropriate.

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, front-loaded with the usage trigger and followed by the safety and return notes. Nothing is padded, though the safety sentence largely duplicates the annotations.

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-param, read-only tool returning a static convention, the description covers the trigger, the safety envelope, and the return type. No output schema exists, so a brief note on the convention's shape would help, but it 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?

The tool takes zero parameters, and schema coverage is 100%, so there is no parameter semantics to explain. Baseline 4 applies for a parameterless tool.

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 return artifact — a JSON telemetry convention for admission trace fields — with the verb 'Returns' and the resource 'JSON telemetry convention'. It is clear what the tool yields, though it makes no effort to distinguish itself from the many sibling meta/inspection 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?

It gives an explicit trigger ('Use when designing trace fields that keep action admission separate from verification verdicts'), which is genuinely actionable. However, it names no alternatives and states no when-not-to-use condition against the large sibling set.

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 cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint=false), so the 'Read-only, zero-auth, no external side effects' sentence is largely redundant. However, the description does add genuinely new behavioral context not in structured fields: the result is a *synthetic* fixture, it is marked unredacted, and URL/title context is retained.

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 tight sentences with no filler, and the rarer behavioral details (unredacted, URL/title retained) are placed after the usage trigger. The opening 'Use when a host needs...' clause is slightly circular, keeping it just under a 5.

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

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

With no input parameters and no output schema, the description must convey the return shape, and it does: a JSON browser-evidence packet, unredacted, with URL and title context. That is sufficient for an agent to invoke it correctly, though nothing explains how the packet is structured or what 'contract inspection' yields.

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 takes zero parameters and schema coverage is 100%, so there is no parameter semantics for the description to carry. Baseline 4 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 states a specific resource (a synthetic browser-evidence fixture) and its purpose (contract inspection), plus what it returns (a JSON browser-evidence packet). It is clear on its own, but it never differentiates itself from the large crowd of sibling proof/context/telemetry fixtures, so an agent can only pick it by name matching.

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?

'Use when a host needs the synthetic browser evidence fixture for contract inspection' gives a usage trigger, but it is circular and adds no when-not guidance, prerequisites, or named alternatives among siblings like telos.proof or telos.context.pack. Usage is implied rather than instructed.

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 cover readOnly, idempotent, non-destructive and closed-world, so the bar is lower. The description still adds the 'zero-auth' requirement and 'no external side effects', which are not encoded in the annotations, plus the return shape.

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 the usage trigger front-loaded and the behavioral guarantees and return type following. No filler or redundancy.

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

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

For a zero-param, no-output-schema read tool the description is nearly sufficient: it names the content ('tools and next actions') and the return format ('JSON catalog'). It stops just short of describing the catalog's structure, which would be the only remaining gap.

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

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

Zero parameters, so the schema-side burden is nil and the baseline is 4. The description correctly implies no input is needed by framing it as a pure read of the catalog.

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 resource ('provider-neutral catalog of Project Telos MCP tools and next actions') and clarifies its scope as provider-neutral text. It distinguishes itself reasonably from siblings like telos.status or telos.server.manifest, though the boundary against telos.server.manifest is not spelled out.

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?

Opens with an explicit trigger ('Use when a host needs the provider-neutral catalog...'), giving a clear condition for invocation. It does not state when NOT to use it or name a sibling alternative, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint, and openWorldHint, so the safety profile is covered; the description reinforces it with 'zero-auth, no external side effects' and adds the return form ('a JSON CI doctor register'). It adds value beyond structured fields without contradicting them.

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 tightly packed sentences, front-loaded with the trigger condition and output. 'Read-only' mildly repeats readOnlyHint=true but the phrase is compact and the rest 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 zero-param, no-output-schema read-only diagnostic, the description covers the trigger, the safety posture, and the return form. It stops short of describing what 'receipts' or the 'register' contain, but that is a minor gap for a tool with no inputs.

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 takes zero parameters, so there is nothing for the description to disambiguate; baseline for 0 params is 4. The description correctly implies a no-argument diagnostic call.

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 pairs a specific resource (GitHub Actions runtime, action-major, and flagship CI compatibility receipts) with the 'CI doctor register' output, so the agent knows this is a CI compatibility diagnostic. It is clear but does not explicitly differentiate itself from siblings like telos.ci.triage or telos.compatibility.doctor, which could plausibly overlap.

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 states a clear trigger condition - 'Use when a host needs GitHub Actions runtime, action-major, and latest five-flagship CI compatibility receipts'. However, it names no alternatives or exclusions despite a crowded sibling set (telos.ci.triage, telos.doctor), so routing between CI tools remains an 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?

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so safety is covered; the description's 'no external side effects, no external writes' is largely redundant. It does add genuinely new context: the auth model (zero-auth offline fixtures, live gh run intake using local gh auth when required) and the triage outcome vocabulary.

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?

Front-loaded with the 'Use when' clause and organized into trigger, safety, auth, and output sentences. It is slightly wordy and repeats the read-only claim already carried by annotations, but no sentence is pure 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?

Despite having no output schema, the description discloses the return vocabulary (JSON MATCH, DRIFT, or UNVERIFIABLE receipts), and it covers the two execution modes and auth requirements. With an empty input schema and rich annotations, an agent has everything needed to invoke and interpret 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 tool takes zero parameters (additionalProperties false), so there is no parameter semantics gap to fill and the baseline of 4 applies. Nothing in the description is needed to interpret an input schema that is empty.

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 (triage) and resource (CI failures), and sharpens it with a concrete scope: separating fatal GitHub Actions gate failures from Node runtime migration warnings. It does not name the closely related sibling telos.ci.doctor to explain how triage differs from a CI doctor check, so sibling differentiation is only implicit.

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 opening 'Use when a host needs to separate fatal ... gate failures from ... migration warnings before routing remediation' gives a clear triggering context. It also clarifies the two intake modes (zero-auth offline fixtures vs live gh run intake), but names no explicit alternative tool or when-not-to-use condition.

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 largely restates what annotations already declare: readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=false already establish read-only, no-side-effect behavior. It does add 'zero-auth' and the return vocabulary (MATCH, DRIFT, UNVERIFIABLE), which is genuinely new context, but the rest is redundant against structured fields.

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

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

Three sentences, front-loaded with the usage trigger, all reasonably tight. Minor redundancy with the annotations ('Read-only, zero-auth, no external side effects') keeps it from being maximally economical.

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, the description usefully names the return contract (JSON MATCH/DRIFT/UNVERIFIABLE receipts). Combined with a zero-parameter schema and full annotation coverage, this is close to sufficient, though it never says what a 'receipt' contains beyond its status.

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 takes no parameters, so the 4 baseline applies. There is nothing for the description to compensate for on the input side.

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+resource (compatibility check) and enumerates the domains it covers: CLI, MCP, protocol, manifest, and integration. It is distinguishable from the many sibling 'doctor' tools by domain, though it does not explicitly name or contrast any sibling, 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?

"Use when a host needs ... compatibility receipts" gives a clear positive trigger, which is better than nothing. But in a family crowded with doctor tools (telos.doctor, telos.ci.doctor, telos.presentation.doctor, etc.), no exclusions or alternatives are given to route the agent between them.

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 largely restates what annotations already declare: 'Read-only' echoes readOnlyHint=true and 'no external side effects' echoes openWorldHint=false. The only marginal additions are 'zero-auth' and the mention of a convention return, which are thin for a tool with no output schema.

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

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

Three short, front-loaded sentences with no padding; the trigger condition leads. Ordering is slightly unusual in leading with usage rather than purpose, but nothing is wasted.

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-param, no-output-schema tool this is adequate: it states when to call it and roughly what comes back. But 'context-envelope convention' stays abstract and the description does not clarify what the envelope actually contains or how it differs from the sibling pack/receipt 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?

The tool takes zero parameters, so the schema imposes no semantic burden and the baseline for a 0-param tool applies. The description appropriately avoids inventing parameter 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 conveys content ('readable source refs, budgets, and receipt chains') and a return type ('a JSON context-envelope convention'), but never states a clear verb or resource that distinguishes it from close siblings like telos.context.pack, telos.action.receipt, or telos.loop.ledger. An agent gets a topic, not a differentiated purpose.

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

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

It gives an explicit trigger condition ('Use when large-workspace context needs...'), which is more than nothing. However, it names no alternatives and provides no when-not guidance, leaving the agent to guess against a crowded set of context/receipt 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is largely covered. The description still adds genuinely new context: zero-auth requirement and no external side effects, plus the fact that output is validated with hashes and verdicts. This goes beyond what annotations state, though it doesn't discuss determinism or failure modes.

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, front-loaded with the usage condition followed by safety and return characteristics. Every sentence carries distinct information with no repetition of the title or annotations.

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 zero parameters and no output schema, the description usefully compensates by disclosing the return shape (validated JSON with hashes and verdicts) and the safety profile. Only minor gaps remain, such as what "bounded" means in practice or what inputs the packet is derived from.

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 takes zero parameters, so the schema carries no semantics to explain and the baseline of 4 applies. Nothing in the description misrepresents or over-explains the empty parameter surface.

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 and scope: producing a bounded handoff packet for large-codebase agent work, and it names the output (validated JSON context pack with hashes and verdicts). It does not differentiate itself from the closely named sibling telos.context.envelope, leaving the agent to guess which packet-producing tool to pick.

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?

"Use when preparing a bounded handoff packet for large-codebase agent work" gives a clear triggering condition, which is more than most siblings offer. However, no exclusions or alternative tools are named, so the boundary against telos.context.envelope or telos.context.pack's own neighbors is left 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 annotations already declaring readOnlyHint, openWorldHint, idempotentHint=false, and destructiveHint=false, the description still adds substantial behavioral context: robots.txt checking, bot-check stopping, no auth/cookies, a named User-Agent, per-host pacing, and 429/503 backoff. This is unusually rich disclosure for a fetch 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?

Four sentences are front-loaded with the use case, then safely ordered into read-only behavior, network behavior, and return shape. Each sentence carries distinct and useful information with no 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?

Annotations already cover safety and openness, and the description fills remaining gaps around robots.txt, auth, pacing, backoff, and return content. Since there is no output schema, the description appropriately explains that a JSON page and fetch receipt are returned.

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

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

The input schema has 100% description coverage for the single url parameter, and the description adds only the scope phrase 'one public URL' rather than format or validation details beyond the schema. With the schema doing the heavy lifting, the baseline is appropriate.

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

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

The description states a specific verb and resource: reading one public URL and returning its text, feed items, sitemap URLs, or JSON. It clearly scopes the tool to a single URL, though it does not explicitly name or distinguish itself from the related sibling telos.crawl.site.

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 begins with an explicit 'Use when' condition covering the content types an agent may need from one URL. It does not state when not to use it or point to an alternative sibling for site-level crawling.

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?

Although annotations already declare readOnly/openWorld/non-destructive, the description adds substantial behavior the annotations cannot convey: robots.txt and Crawl-delay compliance, a single honest User-Agent, per-host pacing with backoff on 429/503, no login or cookies, and the return shape (JSON summaries plus a receipt). This is exactly the extra context structured fields cannot carry.

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?

Front-loaded with the trigger condition, then layered constraints and behavior with no filler sentences. It is dense--one very long compound sentence--but every clause carries operational information.

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

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

With no output schema, the description compensates by stating the return (JSON page summaries and a receipt), and it covers safety, auth, and rate-limit behavior. The gap is same_host, whose purpose is never explained, and no hint of what the receipt contains.

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 75%, so url, depth, and page_budget are already documented in the schema. The description repeats the depth (0-3) and page budget (1-50) ranges rather than adding meaning, and same_host is left unexplained in both places. Baseline 3 is appropriate.

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

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

It gives a specific action and scope: 'agent needs several pages of one site', which is a real verb+resource, and the 'several pages' framing implicitly separates it from the sibling telos.crawl.fetch (single page). It stops short of naming that sibling outright, so an agent must infer the boundary.

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?

'Use when an agent needs several pages of one site' gives a clear triggering condition, and the description names the retrieval order (sitemaps and feeds before links). There is no explicit 'do not use this when...' or a named alternative such as crawl.fetch, so routing is left partly 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?

Annotations already declare read-only, idempotent, non-destructive, and closed-world behavior. The description usefully adds zero-auth and no-external-side-effects guarantees plus the return shape, 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 are front-loaded with use context, safety traits, and return type; there is no filler. The first sentence's lane list is long and "presenting" is somewhat vague, but the structure is efficient overall.

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-param read-only tool with full annotation coverage, the description supplies the essential facts: read-only, zero-auth, no side effects, and returns JSON. It could say more about the manifest contents, but the absence of an output schema is only a minor gap.

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

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

There are zero parameters, so the baseline is 4. The description adds no parameter detail, but none is needed for this no-arg tool.

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 that the tool returns a JSON creative-engine manifest and scopes it to creative-engine lanes, identifying the resource and output. It does not differentiate this tool from siblings like telos.creative.kernels or telos.rendering.capabilities, 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?

It gives an explicit usage context ("Use when presenting the Telos Creative Engine across ... lanes") but no when-not-to-use conditions or named alternative siblings. The context is clear, but routing guidance is incomplete.

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 cover read-only, idempotent, and non-destructive status, and the description adds meaningful context beyond them: zero-auth (no credential setup needed) and no external side effects. It stops short of describing the kernel format or any size/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?

Three tight sentences: trigger condition first, safety/auth profile second, return type last. No filler, every sentence carries information.

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

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

For a zero-parameter, read-only tool with annotations covering the safety profile and no output schema, the description supplies enough to invoke it correctly. The only minor gap is that it does not hint at the structure of the returned JSON kernels.

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 takes zero parameters with 100% schema coverage, so the baseline is 4. There is nothing further the description could clarify about inputs.

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

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

The description states a resource (deterministic creative primitives) and enumerates concrete use domains: dithering, pixel sorting, plotter paths, and clustered-light bins. An agent gets a clear sense of what it returns, though the sibling telos.creative.engine is not distinguished from it.

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?

'Use when deterministic creative primitives are needed for...' gives clear triggering context with specific examples. It offers no when-not guidance and does not name an alternative, so the boundary with telos.creative.engine remains implicit.

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

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

The description asserts 'Read-only, zero-auth, no external side effects', but readOnlyHint, idempotentHint, destructiveHint and openWorldHint already convey most of that, so the value added is limited to 'zero-auth' and the fact that a JSON contract is returned. It does not disclose contract contents, versioning, or edge-case behavior beyond the annotations.

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

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

Two tight sentences, front-loaded with the trigger condition followed by the guarantees and return type. Slight redundancy with the annotations in the second sentence keeps it from being maximally efficient.

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

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

For a zero-parameter, no-output-schema, read-only contract tool, the description covers trigger, safety profile and return shape well enough to invoke correctly. Only the exact structure of the returned contract is left unspecified, which is acceptable given there is no output schema to rely on.

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 takes zero parameters and the schema is an empty closed object, so there is nothing for the description to disambiguate. The baseline of 4 applies; the description correctly signals this is a parameterless contract fetch.

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 resource (display-calibration contract) and the domains it covers (display, color, ICC/LUT, artifact refs, measurement gates), plus the verb-like outcome 'returns a JSON display-calibration contract'. It is clear what the tool yields, though it does not sharply differentiate itself from adjacent siblings like telos.proof.visual or telos.rendering.capabilities.

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 'Use when ...' clause does give a positive trigger condition across several domains. However, there is no when-not guidance and no alternative named among ~37 siblings, so an agent cannot tell what to pick instead of this when the condition is only partially met.

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 readOnlyHint, idempotentHint, and destructiveHint=false. The description adds genuinely new context: zero-auth requirement, no external side effects, and that results are returned as JSON. It does not describe failure modes or what a failing check 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?

Two short sentences with no filler; the use case is front-loaded before the behavioral traits. Every clause 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 no-parameter, read-only health check this is nearly complete. With no output schema, the mention of 'JSON check results' is the only hint at return shape, which is a minor gap for interpreting pass/fail output.

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 takes zero parameters, so the baseline is 4. The description correctly conveys that no input is needed, and there are no parameters for the schema to document.

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+resource ('check local Telos operator-spine health'), which is clear on its own. It does not explicitly distinguish itself from the many sibling doctor tools (ci.doctor, presentation.doctor, operator.doctor), though 'operator-spine' narrows the scope reasonably.

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 concrete triggering contexts ('before demos, listings, or agent runs'), which is clear usage guidance. It names no alternatives or exclusions, so an agent must infer when a more specific doctor tool is preferred.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint=false, and destructiveHint=false, so the description's 'Read-only, zero-auth, no external side effects' mostly restates them. It does add the 'zero-auth' detail and notes it returns a JSON Learning Forge packet, which is useful, but return format and triggering preconditions remain thin.

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 the usage trigger front-loaded, and no filler. It is compact and appropriately sized, though the dense jargon slightly reduces scannability.

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

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

For a zero-parameter, fully-annotated tool with no output schema, the definition covers the essentials but leaves the actual operation and the shape of the returned 'JSON Learning Forge packet' undefined. Against rich annotations the bar is lower, so this is adequate but not complete.

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

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

The tool takes zero parameters and schema coverage is 100%, so there is nothing for the description to disambiguate. Baseline of 4 applies since no parameter semantics are needed.

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 conveys that this registers/forges leads (video, channel, paper, benchmark) into 'receipt-backed learning labs,' which is a specific transformation, but the jargon ('leads,' 'receipt-backed learning labs') is opaque. It does not differentiate itself from the very close sibling telos.learning.labs, so an agent cannot easily tell them apart.

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

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

It provides a usage trigger ('Use when... before synthesis'), which is real contextual guidance. However, it names no alternatives or exclusions, and the sibling telos.learning.labs is not mentioned as a competing option, so the routing value is only implicit.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so "Read-only, zero-auth, no external side effects" largely restates what the structured data provides. The one piece of genuinely additive context is the return format ("Returns a JSON Learning Forge labs packet"), which is useful given no output schema exists. Net value beyond annotations is modest.

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, front-loaded with the activation condition, so the agent sees the trigger first. Slight redundancy between "Read-only" and "no external side effects" (both already covered by annotations) costs it a point.

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 parameters, dense annotations, and no output schema, the description covers the three things an agent needs: when to call it, that it is side-effect-free, and that it returns a JSON labs packet. Nothing essential is missing for a zero-input read tool.

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

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

The tool takes zero parameters, so the baseline of 4 applies. The description correctly implies no input is required, and there are no parameter semantics to document or omit.

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 the resource ("Learning Forge labs packet") and the trigger (source leads needing executable lab contracts), but the verb is left implicit and the phrasing is dense domain jargon ("executable lab contracts", "five-flagship ownership"). An agent can infer it produces a labs packet, but the purpose is not stated in a clean verb+resource form, and it does not explicitly differentiate itself from the adjacent telos.learning.forge 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?

"Use when Learning Forge source leads need executable lab contracts..." is an explicit activation condition rather than an implied one. However, it offers no when-not guidance and does not route the agent to or away from any alternative sibling, which would be needed for a 5.

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

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

Annotations already cover the safety profile (read-only, idempotent, non-destructive, closed-world), but the description adds material context: 'zero-auth, no external side effects'. That is genuinely useful beyond structured fields, though it doesn't explain what the returned convention contains or any caveats.

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, front-loaded with the usage condition, then the safety profile, then the return shape. No filler and nothing to trim.

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 parameters, full annotation coverage, and no output schema, the description only needs to explain the purpose and return value. It gestures at 'a JSON loop-ledger convention' but never defines what that convention is or what an agent does with it, which is the key missing piece for this abstraction.

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 takes zero parameters, so the baseline is 4. There are no arguments to clarify and the description correctly implies a parameterless retrieval operation.

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 use case ('durable state across fresh contexts and bounded scheduled runs') and an output ('a JSON loop-ledger convention'), but the core resource is abstract and undefined — 'loop ledger' is not explained. It does not differentiate from the many similarly abstract sibling tools like telos.context.envelope or telos.objective.monitor.

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 'Use when...' provides an explicit trigger condition (agent loops needing durable state across fresh contexts). However, no alternatives or exclusions are named despite dozens of related sibling tools, leaving the agent unsure whether this or telos.context.pack is the right choice.

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 readOnlyHint, idempotentHint, and openWorldHint=false, so "Read-only, zero-auth, no external side effects" largely restates structured data. What the description does add beyond annotations is the outcome model (JSON MATCH, DRIFT, or UNVERIFIABLE receipts), which is valuable given there is no output schema.

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

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

Two tight sentences; the usage trigger is front-loaded and the remaining clause covers behavior plus return values with no filler. Nothing here feels padded or redundant beyond a minor overlap with the annotations.

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-argument, no-output-schema tool the description covers trigger, safety posture, and outcome vocabulary, which is close to sufficient. It does not explain where the "expected" baseline comes from or how to act on DRIFT/UNVERIFIABLE, leaving a small interpretive gap.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Per the zero-parameter baseline, a 4 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?

States a specific verb (compare) and resource (loaded MCP servers against expected versions, tools, and probes), giving an agent a clear picture of the operation. It is largely distinguishable from siblings like telos.status or telos.server.manifest, though it never explicitly names an alternative to route between them.

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?

"Use when a host must compare loaded MCP servers against expected versions, tools, and probes" is an explicit triggering condition, not an implied one. There are no exclusions or named alternative tools, so it stops short of a 5.

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

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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, and the description adds genuinely new behavioral facts: zero-auth, no external side effects, SHA-256 receipts, and the two response variants (v1 demo packet vs v2 caller-image packet). It stops short of clarifying failure modes (bad ROI, disallowed path, oversize resample) but clears the annotation-adjusted bar well.

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 trigger condition is reasonably front-loaded and every sentence carries some information, but the opening sentence is a comma-spliced pile-up of seven evidence domains and the whole block reads as compressed internal shorthand rather than a crisp contract.

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 10-parameter, nested-object tool with no output schema and near-zero schema coverage, the description leaves too much unexplained: what each layer computes, what n/roi/resample do, what the receipt covers, and what the packet contains beyond a version label. It is under-specified for the tool's 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 only 10% across 10 parameters, so the description must carry the burden, yet it only explains the image input (raw 8-bit RGBA, inline base64 or local-root file) and the L0–L3 layer selection. n, roi, resample, declared, overlays, overlays_drawn, frame_id, and run_id are left entirely undocumented in both description and 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 names a concrete verb/resource (Telos measurement layers L0–L3 with SHA-256 receipts) and enumerates the evidence domains it covers (visual, splat, lighting, dither, audio, uncertainty, frame-budget), and it explicitly routes away from proof-oriented siblings. The jargon density and the missing-article run-on ('needs meters, or when...') slightly blunt first-read clarity, but an agent can distinguish it from 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?

'Use when ... evidence needs meters' gives a real trigger context, and 'Called with no arguments it returns the demo meters' tells the agent the trivial-call behavior. However, no sibling alternative is ever named (e.g. telos.proof.visual, telos.display.calibration, telos.browser.evidence), and there is no when-not guidance despite many overlapping evidence tools in the family.

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 readOnlyHint, idempotentHint, non-destructive, and closed-world, so the safety profile is covered. The description still adds real value beyond them: 'zero-auth' and 'no external side effects' are not derivable from the annotations, and it discloses the return type (a JSON contract). It stops short of describing the contract's content or any 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?

Two tight sentences with no filler: the trigger first, then the safety/return profile. The scope enumeration in the first sentence is jargon-dense but each item earns its place as a coverage claim.

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

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

No input schema, no output schema, and annotations already cover the safety profile, so the description is the only source of what 'a JSON model-foundry contract' actually contains — and it doesn't say. For a zero-input tool whose entire value is the returned contract, that is a meaningful gap, and there is no routing guidance against sibling registers.

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 takes zero parameters, so there is nothing for the description to disambiguate; baseline for a 0-param tool is 4. Schema coverage is trivially 100%.

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 domain (model foundry) and enumerates scope areas (hosted, local, open-weight, post-training, verifier gates), and states it returns a JSON model-foundry contract. But it never states a concrete action verb beyond 'planning', and with 40 sibling telos.* tools it offers no differentiation from neighbors like telos.learning.forge or telos.catalog. The purpose is inferable but vague.

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?

'Use when planning model-foundry work' gives a trigger condition, so guidance is implied rather than absent. However, the trigger is essentially circular (use the model-foundry tool when doing model-foundry work), and no alternative sibling tool is named for adjacent tasks. No when-not guidance either.

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 readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false. The description still adds value beyond them by stating 'zero-auth' and 'no external side effects' and by noting the return shape is a JSON catalog, which the annotations do not cover.

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

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

Two sentences, front-loaded with the usage condition, then capability scope and safety. Nothing is redundant against the annotations and there is no 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 parameterless, read-only discovery tool with no output schema, the description covers when to call it, what it returns, and its safety posture. Only a brief note on the catalog's structure or size would improve it further.

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 takes zero parameters, so there is nothing for the description to disambiguate and the baseline is 4. No misleading parameter claims are made.

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 concrete verb+resource ('returns a JSON capability and verb catalog') and names the specific actuation domains, Chrome DevTools Protocol and Windows UI Automation. It stops short of distinguishing itself from generic look-alikes such as telos.catalog or telos.server.manifest, so an agent still has to infer which catalog it needs.

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?

'Use when a host needs the Telos native background-control capability catalog' gives a clear triggering condition, and the enumerated device/learn verbs add scope. No exclusion or alternative-naming guidance is provided, so 4 rather than 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the description's 'Read-only, no external side effects' largely repeats structured data. It does add one non-redundant fact ('zero-auth') and notes the return medium (JSON signals), but adds little behavioral depth beyond the annotations.

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

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

Two tight sentences with the use condition front-loaded and no wasted words. Every clause carries relevant information.

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

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

With no output schema, the description should carry return-value burden, but 'Returns JSON objective-monitor signals' is vague about what those signals contain. For a zero-param monitoring tool this is adequate but leaves the agent guessing about output shape.

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 takes zero parameters, so there are no parameter semantics to convey. Baseline score of 4 applies since there is nothing the description needs to compensate for.

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 monitoring concept: detecting when proxy metrics drift from real agent/build objectives. Clear verb-ish framing ('checking') and resource (objective-monitor signals), though it does not explicitly distinguish itself from siblings like telos.measurement.layers.

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?

'Use when checking whether proxy metrics are drifting away from real agent or build objectives' gives a concrete trigger condition. However, it names no alternatives or exclusions for when this tool should not be chosen over related diagnostic 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?

Annotations already declare read-only, idempotent, non-destructive, closed-world, so the safety profile is covered. The description still adds value beyond them: zero-auth requirement, no external side effects, and the three possible verdict values (MATCH, DRIFT, UNVERIFIABLE). It does not disclose runtime cost or which telltale produces DRIFT.

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, front-loaded with the usage trigger ahead of behavioral and return-value details. Dense with internal jargon ("receipts", "current-state discoverability") but no sentence is wasted.

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 and no parameters, so the description carries the primary burden; it names the return vocabulary (MATCH/DRIFT/UNVERIFIABLE) and the checked surfaces, which is enough to call and interpret the tool. It would be fully complete with one line clarifying how it relates to telos.doctor and telos.ci.doctor.

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?

Zero input parameters, so there is nothing for the description to disambiguate; schema coverage is 100% and additionalProperties is false. Baseline 4 applies, and the description correctly implies a parameterless invoke with no required arguments.

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 outcome (health-check receipts) for a specific resource (the Telos operator surface) and enumerates the artifacts inspected (README, status, catalog, manifest, CI, discoverability). It is clear what the tool does, but it never distinguishes itself from near-siblings like telos.doctor, telos.ci.doctor, or telos.status, which check overlapping surfaces.

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?

"Use when a host needs ... receipts" supplies an explicit trigger condition, which is more than most definitions offer. However, there are no exclusions or named alternatives, and with telos.doctor, telos.ci.doctor, and telos.catalog in the sibling list the agent gets no guidance on when this composite check is preferred over those narrower ones.

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 readOnlyHint, idempotentHint, and openWorldHint=false, so the safety profile is largely covered. The description still adds genuinely new context: 'zero-auth' (not in annotations) and the three possible outcome states (MATCH, DRIFT, UNVERIFIABLE), though it does not explain what those states mean. 'No external side effects' overlaps with openWorldHint=false.

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

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

Two sentences, front-loaded with the 'Use when' trigger, no filler, and the behavioral/output summary second. Every clause carries information an agent needs.

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 parameters and no output schema, the description reasonably carries the return-value burden by naming the three possible receipt states but leaves what MATCH/DRIFT/UNVERIFIABLE signify to inference. Safety behavior is covered by annotations, so overall it is nearly complete, falling just short on defining the output states.

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 takes zero parameters, so there are no parameter semantics to document; baseline for a parameterless tool is 4. The description introduces no parameter-like arguments or filtering options that would need explaining.

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 resource domain (static Studio performance, efficiency, asset-budget, and embedding receipts) and the output artifact (performance receipts), which distinguishes it from the many sibling '*doctor' tools like ci.doctor, accessibility.doctor, and compatibility.doctor. The verb is implicit in 'doctor/check' rather than stated outright, and it never names a sibling to differentiate against explicitly, 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?

It opens with an explicit trigger, 'Use when a host needs static Studio performance... receipts,' giving clear context for when to invoke it. There is no when-not guidance and no named alternative among the numerous sibling doctors, so it lacks the routing precision of a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint, and openWorldHint, so the description's 'Read-only, zero-auth, no external side effects' largely repeats structured data. It does add the return statuses (MATCH, DRIFT, UNVERIFIABLE), which is genuine extra context beyond annotations.

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

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

Two tight sentences, front-loaded with the 'Use when' trigger and followed by the safety envelope and return statuses. No filler, though 'five-flagship' is opaque jargon that costs clarity rather than length.

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-param, read-only check with no output schema, the description is adequate: it states the trigger, the safety profile, and the possible return statuses. However, it doesn't explain what 'five-flagship' means, how the receipts are produced, or what a DRIFT/UNVERIFIABLE result implies, leaving the agent under-informed about the operation's actual output.

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?

Zero parameters, so baseline is 4 per the rubric. The description needn't explain parameters, and the schema is trivially empty.

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 ('check') and resource (presentation parity of README, changelog, brand assets), which is more specific than the title. However, the phrase 'five-flagship' is jargon and the scope of what is actually checked stays vague, making it hard to tell apart from sibling doctors like telos.proof.visual or telos.display.calibration.

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 'Use when...' clause gives an implied context (host needs presentation parity receipts), which is better than nothing. But there are no explicit alternatives, exclusions, or when-not-to-use guidance despite a large set of sibling doctor/proof/visual tools that could overlap.

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 readOnly, idempotent, non-destructive, non-open-world. The description adds genuinely new context: 'zero-auth' and 'no external side effects beyond local subprocess reads,' clarifying that it executes local subprocesses despite being read-only. That subprocess disclosure is valuable and not in 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?

Two sentences, front-loaded with the trigger condition and the composed evidence list, then the safety/return profile. The enumerated list is long but each item carries meaning for the packet's contents; little waste.

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

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

With no parameters, no output schema, and annotations covering safety, the description supplies the remaining essentials: trigger condition, composition, return type, and side-effect profile. It is complete enough to call correctly, though it doesn't explain the format or size of the returned packet.

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 takes zero parameters, so there is no parameter surface to document; baseline 4 applies. The schema's empty-object definition is consistent with the description, which accurately implies a no-input invocation.

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

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

States a specific verb and resource: assembling a 'fixture-backed agent-action proof packet' that joins enumerated evidence streams plus an Emet witness stage. The 'agent-action' qualifier distinguishes it somewhat from the proof.research/visual/build siblings, but the description never explicitly contrasts with them or with telos.action.receipt, so sibling differentiation is left implicit.

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 opening 'Use when a host needs...' gives a trigger condition, which is better than nothing. However, no alternatives are named (unlike a strong definition that would route to proof.research or action.receipt), and there is no when-not guidance, so usage is only implied.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds genuinely new context: zero-auth, no side effects beyond local subprocess reads, and the requirement of a negative fixture that must break the invariant. These operational/auth details go beyond the structured 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?

Overall length is reasonable at three sentences, and the safety/return facts are front-loaded at the end. However, the lead sentence is a dense run-on packed with undefined jargon ("conserved-quantity invariant", "conservation drift", "stdlib math") that impedes parsing.

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 parameters and no output schema, the description must carry the return-value and behavioral burden, and it does so partially – it names the JSON return and the fixture/invariant mechanics. It stops short of describing the packet's structure, but that is a minor gap for a no-arg build tool.

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

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

The tool takes zero parameters, so the baseline is 4; there is nothing for the description to disambiguate. The behavioral preconditions it states (embedded samples, negative fixture) substitute for the absent parameter surface.

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 and resource – builds a "fixture-backed build scientific-runtime proof packet" – and details the invariant/drift mechanics it computes. It is clear what the tool does, but it never differentiates itself from the close siblings telos.proof, telos.proof.research, and telos.proof.visual, leaving the agent to guess which proof tool applies.

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 opening "Use when a host needs the fixture-backed build scientific-runtime proof packet" is a usage condition, but it is circular (it restates the purpose) and gives no exclusions or routing to the sibling proof tools. Usage is implied rather than stated, so a 3 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?

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description still adds value beyond the schema by asserting 'zero-auth' and 'no external side effects beyond local subprocess reads', disclosing the auth requirement and the subprocess-read 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?

Two sentences, front-loaded with the 'Use when' trigger and ending with the return type. The middle sentence is a dense comma-list of packet components, but each item earns its place by defining the packet's contents.

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 input parameters and no output schema, the description must cover both invocation and return, which it does by describing the joined components and stating it returns a JSON packet. The only shortfall is the lack of explicit sibling routing for a family of four proof 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?

The tool takes zero parameters, so there is no parameter semantics to convey and the schema cannot be under-documented. Baseline 4 applies; the description correctly implies a no-argument invocation.

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

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

The description names a specific resource ('research-claim proof packet') and enumerates the artifacts it joins (source provenance, bounded claim, negative control fixture, attempt records, recomputed digests, derived promotion rung), which is far beyond a tautology. It reads as distinct from telos.proof.visual and telos.proof.build via the 'research-claim' framing, but never explicitly contrasts itself with those 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?

'Use when a host needs the fixture-backed research-claim proof packet' gives an implied trigger condition, but it is circular and names no alternatives or exclusions. With three sibling proof tools (telos.proof, telos.proof.visual, telos.proof.build), the absence of routing guidance is a clear 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?

Annotations already declare readOnly/idempotent/non-destructive, so safety is covered. The description still adds value beyond them: 'zero-auth', 'no external side effects beyond local subprocess reads', and the no-overclaim boundary about physical calibration. It stops short of describing the packet's structure or any runtime cost.

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

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

Two sentences, front-loaded with the trigger, but the first sentence is an over-packed clause chain ('whose color and luminance measurements are recomputed from the artifact's own embedded sRGB samples'). 'Read-only' is stated in both sentences, a small redundancy that costs it above 3.

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 parameters, no output schema, and annotations carrying the safety profile, the description supplies the remaining essentials: the purpose, the recomputation guarantee, and the auth/side-effect footprint. Adequate for an agent to invoke it, though returning 'a JSON visual-truth proof packet' is vague about actual contents.

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 takes zero parameters with an empty, closed schema, so there is nothing for the description to document. Baseline 4 applies; no parameter meaning is missing.

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

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

States a specific resource (a fixture-backed visual-truth proof packet) with the key mechanism (color and luminance measurements recomputed from the artifact's own embedded sRGB samples), and the 'no physical-calibration overclaim' clause implicitly separates it from telos.display.calibration. It does not name siblings explicitly, but the scope is concrete enough to distinguish it from telos.proof/build/research.

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?

Opens with an explicit trigger ('Use when a host needs...'), which gives real usage context. However, it names no alternatives and states no when-not condition, so an agent cannot tell from this description alone how to choose between this and the other telos.proof.* or measurement 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?

Annotations already declare readOnly/openWorld/non-destructive, and the description adds substantial context beyond them: keys live in YOUTUBE_API_KEY/BRAVE_SEARCH_API_KEY and travel in headers, never in receipts; one honest User-Agent with per-host pacing and backoff on 429/503; no login, no cookies; returns JSON plus a receipt. This is rich operational detail consistent 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?

Front-loaded with the "Use when..." trigger, followed by tight sentences covering supported channels, auth, network behavior, and return shape. Every sentence carries information, though the dense multi-clause sentence about channel/auth splits is slightly crammed.

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 3-param, 7-channel read tool with no output schema, the description covers auth requirements, rate-limit/backoff behavior, and that it returns JSON plus a receipt. It leaves the meaning of the receipt and per-channel operation semantics unexplained, but the essentials for correct invocation are present.

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 sits at 67%, and the schema already documents op (with examples like top, item, repo, search), params (with an example), and the channel enum. The description restates the channel list but adds no parameter syntax, required-combination, or per-channel op guidance beyond the schema, 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 states a specific verb and resource (one operation from an official API) and enumerates the exact channels supported (hackernews, github, v2ex, wikipedia, arxiv, youtube, brave). This implicitly differentiates it from siblings like telos.x.api and telos.reddit.listing, which are covered by the excluded channels, but no sibling is named explicitly.

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?

"Use when an agent needs one operation from an official API" gives a clear activation context, and the auth split (zero-auth vs user-key channels) tells the agent which channels require setup. It does not name alternatives or state when NOT to use this tool, so it stops short of full routing 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, and the description still adds real context beyond them: zero-auth requirement, no external side effects, and the specific detail that it only reads environment variable names with no network, file writes or processes. That is exactly the supplementary behavioral disclosure this dimension rewards.

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 tight sentences: the first front-loads the usage cue and the scope of what is checked, the second packs the safety profile and return type. No filler and no repetition of the title or annotations.

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 parameters and no output schema, the description carries the full burden, and it does cover what the report answers (which channels work, their cost and omissions) and that it returns a JSON doctor report. The only minor gap is that the report's field structure is not hinted at, but the content is described well enough to call the tool 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?

The tool takes zero parameters, so per the rubric the baseline is 4. There is nothing the description could add about argument semantics, and it correctly does not invent any.

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 and resource — checking which reach channels (web crawler, Reddit, X, official APIs) work for this user — and frames the tool's role as a pre-flight check. It is clearly distinguishable from telos.reach.api and telos.reach.menu because it is positioned as the diagnostic that runs before an actual call.

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?

"Use before any reach call" gives an explicit trigger condition and ordering relative to siblings. It does not name a specific alternative tool by name or state when-not-to-use, but the sequencing guidance is unambiguous enough that an agent knows exactly when to reach for 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the 'Read-only, zero-auth, no external side effects' clause largely repeats structured data. However, the description adds genuinely new behavior: credentials are checked, it remembers what was already read, and it resolves the memory file from `memory` or TELOS_REACH_MEMORY.

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

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

Two sentences, front-loaded with the 'Use when' trigger, then the safety/behavior and return summary. Efficient, though the safety clause partially duplicates annotations.

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

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

No output schema, but the description at least states it 'Returns a JSON menu.' For a tool whose primary input concept is the tier, leaving the T0–T5 semantics unexplained is a real gap, even with annotations covering the safety profile.

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 50%. The description meaningfully explains the `memory` parameter's resolution order (explicit `memory` vs. TELOS_REACH_MEMORY env var), but the `tier` parameter – the central concept of the tool – is only gestured at as 'grant tier' with no explanation of what T0–T5 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 states a specific verb+resource: it returns the 'reach verbs its grant tier allows' as a JSON menu. An agent can tell it is a discovery/menu tool, though it does not explicitly distinguish itself from nearby siblings like telos.reach.api or telos.reach.doctor.

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 gives a clear trigger condition: 'Use when an agent needs the reach verbs its grant tier allows.' That is explicit context, but there are no exclusions and no named alternatives for when a different reach tool is the better pick.

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 (readOnlyHint, openWorldHint, destructiveHint=false), the description discloses auth source (user's Reddit app credentials in env vars named by telos.reach.doctor), network egress with a single honest User-Agent, per-host pacing with backoff on 429/503, and no login or cookies. This is exactly the operational context an agent needs before invoking a network 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 trigger condition is front-loaded in the first clause, and the remaining sentences each carry distinct operational payload (auth, network policy, return shape). It is dense and slightly run-on but nearly every clause 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 no output schema, the description must cover returns and it does ('Returns JSON comments with depth and a receipt'), while also covering auth, network behavior, rate-limit handling, and the read-only profile. Nothing an agent needs to call 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 coverage is 100%, so the schema already documents post_id (with/without t3_), depth, and limit. The description adds only that returned comments carry depth, not any semantics for limit or depth beyond the schema—baseline 3 is appropriate.

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

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

The description states a specific verb and resource: retrieve one Reddit post plus its comment tree via the official Data API. The 'one post' scope implicitly separates it from the sibling telos.reddit.listing, but it never names that sibling or draws the contrast explicitly, 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?

'Use when an agent needs one Reddit post and its comment tree' gives a clear trigger condition. It offers no when-not guidance or explicit alternative (e.g. telos.reddit.listing for feeds), so it is clear context without exclusions.

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

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

Annotations already declare read-only, open-world, non-idempotent, and non-destructive. The description goes well beyond them: auth via environment variables named by telos.reach.doctor, pacing from Reddit's rate-limit headers, per-host pacing with backoff on 429 and 503, no login/cookies, and a receipt return. This is rich, precise 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?

Three dense sentences, front-loaded with usage and safety, then network behavior, then return format. Every clause adds a distinct fact (auth source, pacing, backoff, no login/cookies) without 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?

No output schema exists, and the description states the return format ('JSON posts and a receipt'). Combined with annotations, it covers auth, rate limiting, backoff, and network profile sufficiently for an agent to invoke correctly. It omits parameter defaults/behavior, but the schema partly covers that.

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 50%, with enums for sort/time and min/max on limit, but the description adds no parameter-level meaning—no explanation of sort/time behavior, limit defaults, or interaction between parameters. It only implies 'posts' and 'subreddit' generally, failing to compensate for the coverage gap.

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

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

States a specific verb and resource: 'needs posts from a subreddit' via Reddit's official Data API. Clear what the tool does, but it does not explicitly differentiate itself from the sibling tool telos.reddit.comments, which likely handles comments versus posts.

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?

Opens with 'Use when an agent needs posts from a subreddit...' giving a clear context for invocation. It does not state when not to use it or name alternatives such as telos.reddit.comments, so it lacks exclusions but provides clear positive 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?

Annotations already declare readOnly, idempotent, non-destructive, and non-open-world, so the safety profile is covered. The description adds useful context beyond that: zero-auth requirement, no external side effects, and the fact that it returns a JSON capability contract.

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 the trigger condition front-loaded, followed by safety posture and return shape. Every sentence carries information and there is no 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 zero-param read-only tool, the description covers when to call it, that it is safe, and that it returns a JSON capability contract. Since no output schema exists, the return shape is only gestured at, which is the one minor gap.

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

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

The tool takes no parameters, and the description correctly implies a parameterless invocation. Baseline of 4 for a zero-param tool is appropriate; there are no parameter semantics to clarify.

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 resource and outcome: returning a renderer capability contract so a host can choose WebGPU/WebGL/canvas/static fallbacks. It is clearly a capability-discovery tool, though it does not explicitly contrast itself with the nearby telos.rendering.research 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?

"Use when a host must choose WebGPU, WebGL, canvas, or static rendering fallbacks for Studio surfaces" gives a clear triggering condition. It lacks explicit when-not guidance or a named alternative tool, but the usage context is unambiguous.

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 readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds valuable context beyond the annotations: 'zero-auth, no external side effects' and 'Returns JSON research seeds' disclose auth requirements and return format, which the annotations do not provide.

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 tightly written sentences with zero waste. The usage condition is front-loaded, followed immediately by behavioral traits and return format, making the definition easy to scan and act on.

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, read-only research register with no output schema, the description supplies everything an agent needs: when to use it, auth and side-effect profile, and return format. No additional context is required to invoke it correctly.

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

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

The tool takes zero parameters, so there are no parameter semantics to document; the baseline for 0 params is 4. The description does not need to add parameter detail, and its mention of return format is appropriately separate.

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: collecting rendering leads and returning JSON research seeds, with domain qualifiers (clustered-forward, Gaussian splatting, creative coding, graphics demos). It clearly distinguishes itself from generic research tools by focusing on rendering, though it does not explicitly differentiate from the closest sibling, telos.rendering.capabilities.

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 opens with an explicit 'Use when collecting rendering leads...' condition, giving clear context for when to invoke the tool. It does not name alternatives or state when not to use it, but the use case is unambiguous.

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 readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so 'read-only' is redundant. The description does add value beyond the annotations with 'zero-auth' (auth requirement) and 'no external side effects', plus the return shape ('JSON research seeds with provenance status'). That is a modest but real increment over the structured fields.

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

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

Three tight sentences with the usage trigger front-loaded, followed by safety profile and return format. Every sentence carries information, though the safety sentence partly restates the annotations.

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-param, no-output-schema tool, the description supplies trigger, safety, and return shape, which is mostly adequate. But the core action remains ambiguous and there's no indication of when this tool should be preferred over adjacent research tools, leaving a gap for an agent deciding whether to invoke it.

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

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

The tool takes zero parameters, so there are no parameter semantics to document and the baseline is 4. Nothing in the description contradicts or adds confusion about inputs.

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

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

The description implies the tool produces 'source-backed seed packets' and returns 'JSON research seeds with provenance status', hinting at a seeding/registration action for research notes. However, the concrete verb is vague — it's unclear whether it registers, generates, or retrieves seeds — and there's no explicit differentiation from the many research siblings (telos.research.thermodynamic, telos.proof.research, telos.rendering.research).

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 'Use when terse research notes need source-backed seed packets before synthesis' gives a clear trigger condition, which is useful context. But there are no when-not conditions and no named alternatives among the crowded research/synthesis siblings, leaving routing 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint=false and destructiveHint=false, so 'Read-only, zero-auth, no external side effects' largely restates structured data. 'Zero-auth' is genuine added context not present in annotations, and the receipt/verification-label mention hints at output shape, but nothing is said about scope, limits, or what the evidence corpus contains.

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, front-loaded with the usage condition before the safety and return notes. Efficient, though the safety sentence duplicates annotations and could have carried new information instead.

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, the description carries the burden of explaining the return, and 'a JSON research receipt with verification labels' is thin — a caller cannot anticipate the receipt's shape or what the labels mean. For a zero-param read-only tool this is adequate but not fully complete.

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

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

The tool takes zero parameters, so there is no parameter semantics to document and the baseline of 4 applies. The description adds nothing here because nothing is needed.

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 activity (exploring thermodynamic/stochastic AI-chip research) and the mechanism (public transcript evidence), plus the return type. It is clearly distinguishable from generic status/doctor siblings, though it never names a nearer alternative like telos.research.seed or telos.proof.research.

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?

'Use when exploring thermodynamic or stochastic AI-chip research' gives a triggering condition, which is more than most siblings offer. However there are no exclusions and no explicit routing between this and the adjacent research/proof tools, so the agent must infer when this is preferred over telos.research.seed.

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 readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so 'read-only, zero-auth, no external side effects' is largely redundant restatement. The one genuinely additive line is that it returns JSON, but nothing is said about contents, size, or freshness of the registry.

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, front-loaded with the usage trigger before the safety and return characteristics. Every sentence is brief and there is no filler or redundancy beyond a small overlap with the annotations.

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 parameters and annotations carrying the full safety profile, the remaining burden is describing the return value, and 'a JSON revival registry' is too thin to tell an agent what it will actually get. For a discovery/decision tool this leaves a meaningful gap, though the safety and usage picture is otherwise complete.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline is 4. No misleading or missing parameter guidance exists because the schema is empty.

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 decision context (promoting older/siloed/frozen local tools into 'flagship lanes') but never states a concrete verb+resource — 'Returns a JSON revival registry' largely restates the name. The metaphor-heavy framing ('flagship lanes', 'revival') makes it hard to tell what the tool actually produces without opening it.

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 opening 'Use when deciding which older, siloed, or frozen local tools should be promoted' gives a clear trigger condition for invocation. No alternatives or exclusions are named, so the agent has no guidance on when NOT to reach for this instead of a sibling like telos.catalog or telos.status.

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

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

Annotations already cover readOnly/idempotent/non-destructive/closed-world, yet the description adds genuinely new context: zero-auth, the required sibling source checkouts and local python interpreter, and the degraded-mode behavior (returns an UNVERIFIABLE envelope naming the missing dependency rather than a live summary). 'Read-only' merely repeats the annotation, and the payload shape is not described, keeping this at 4.

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?

Four sentences, front-loaded with the when-to-use trigger and followed by prerequisites and failure behavior in a logical order. One sentence ('Read-only and zero-auth') partially duplicates the annotations, which is minor waste.

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

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

With no parameters, no output schema, and rich annotations, the description covers the trigger, auth posture, external prerequisites, failure mode, and return kind, which is nearly everything an agent needs. The only thin spot is that 'JSON action envelope' leaves the payload fields unspecified where no output schema exists to help.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. Nothing in the description needs to compensate for missing parameter documentation.

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

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

The description states it returns the current five-flagship room summary and frames it as a pre-routing input, so the agent knows roughly what comes back. However, 'room' and 'five-flagship' are undefined jargon with no output schema to disambiguate, and no sibling tool is named, so an agent cannot confidently tell it apart from telos.status or telos.catalog.

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

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

'Use when an agent needs the current five-flagship room summary before routing work' gives an explicit trigger condition, which is more than most definitions offer. It stops short of naming alternatives or stating when not to use it, so 4 rather than 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so 'read-only' and 'no external side effects' largely restate structured data. The phrase 'zero-auth' does add genuinely new information (no authentication required) not covered by any annotation, and the description correctly discloses the return payload type.

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, front-loaded with the usage condition and with zero filler. The only mildly redundant sentence is the last one, whose return-value claim is arguably implied by the tool name, but it is brief and does useful work.

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, no-output-schema tool the description covers the essentials: purpose, usage trigger, safety profile and return type. It nonetheless leaves the return contract underspecified — what fields a 'flagship queue' entry contains, whether it can be empty, or how candidates are ordered — which for a queue-consuming tool is the main thing an agent still needs.

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 takes zero parameters, so there is no parameter semantics for the description to explain; the schema is trivially complete. Baseline 4 applies, and nothing in the description misrepresents the empty input contract.

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 resource ('a JSON second-level flagship queue') and its domain ('public-safe second-level flagship candidates'), so an agent knows roughly what it retrieves. However, the purpose is expressed in dense internal jargon and never explicitly distinguishes it from likely-overlapping siblings such as telos.revival.registry or telos.catalog.

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

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

It opens with an explicit when-to-use clause: 'Use when assessing public-safe second-level flagship candidates before registry promotion.' That gives a clear situational trigger and even implies the workflow step. It stops short of naming a concrete alternative or a when-not-to-use condition, so it is not a full 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the bar is lower. The description still adds genuinely new context the annotations lack: 'zero-auth' (no credentials needed) and 'no external side effects', which are useful invocation facts.

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: usage condition first, then behavioral guarantees, then the return shape. Every sentence earns its place and the important information 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?

For a zero-param, read-only, no-output-schema tool, the description covers when to use it, its safety/auth profile, and that it returns a manifest. It could be slightly richer by indicating what the manifest contains (server names, endpoints, transports), which an agent configuring clients might want.

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 takes zero parameters, so per the rubric the baseline is 4. There is nothing further the description could meaningfully add about parameter 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 gives a specific verb and resource ('Returns a JSON server manifest') and scopes it to MCP client configuration for named source checkouts. It is clear what the tool does, though it does not explicitly distinguish itself from similarly-named discovery siblings like telos.catalog or telos.mcp.freshness.

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 states a concrete usage context ('Use when configuring MCP clients for gather, index, forum, crucible, and telos source checkouts'), which is a clear when-to-use signal. It does not name alternatives or when-not conditions, so it falls short of full routing 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is pre-covered. The description adds genuinely new context beyond the annotations: 'zero-auth' (auth requirements) and 'fixture-backed' (no live external calls), which an agent cannot infer from the structured fields alone.

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, front-loaded with the 'Use when' trigger, then safety profile, then return note. Every sentence carries distinct information with no padding.

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, read-only, fully-annotated tool, the description covers trigger, safety and return type. 'Returns JSON scout results' is vague about the actual shape, but with no output schema and a trivial invocation surface, this is close to complete.

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

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

Zero parameters, so there is no parameter documentation burden; baseline 4 applies. Nothing in the description is needed to compensate for schema gaps.

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 (scout) and resource (fixture-backed OSS Proof Showcase candidate rankings), and the phrase 'candidate rankings' distinguishes it from siblings like telos.proof or telos.research. The jargon is dense but the purpose is identifiable without opening a 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?

'Use when a host needs ... before public patch work' gives a clear triggering condition and a temporal constraint (pre-patch). No alternatives or negative conditions are named, but the context is unambiguous for a singleton tool of this kind.

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 read-only, idempotent, non-destructive behavior. The description adds zero-auth and no external side effects plus the return type ('JSON action envelope'), which is useful context beyond the annotations.

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

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

Two tight sentences with the usage condition front-loaded and no redundant text. Every phrase 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 zero-parameter status tool with rich annotations, the description covers purpose, usage, and return type. It stops short of describing what fields the 'action envelope' contains, which is a minor gap since no output schema exists.

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

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

Zero parameters; the empty schema is self-explanatory. Baseline 4 applies because there are no parameter semantics for the description to clarify.

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 the tool provides current Telos workbench readiness and next actions, a specific outcome. It does not differentiate from the many sibling telos.* diagnostic tools (e.g., telos.doctor) that an agent might confuse it with.

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?

Explicitly says to use it when a host needs current readiness and next actions, giving a clear trigger. No when-not conditions or named alternatives are provided, so the agent must infer that other telos.* tools handle different scopes.

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 behavioral context beyond the annotations: it declares read-only and zero-auth (matching annotations), but crucially discloses the failure mode — it returns an UNVERIFIABLE envelope naming the missing dependency rather than failing opaquely. It also discloses the dependency requirements (sibling checkouts + local python) and the return shape (JSON receipts and verdict counts). The annotations already cover safety profile; the description earns credit for the dependency preconditions and graceful-degradation 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?

Three tightly packed sentences: trigger/scope, behavioral properties and failure mode, then return shape. Each sentence carries distinct load — no repetition, no filler. The 'use when' clause is front-loaded and the fallback behavior is stated before the return format, which is a sensible ordering.

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-param, read-only diagnostic with no output schema, the description covers the preconditions (sibling checkouts, python), the failure mode (UNVERIFIABLE envelope), and return content (JSON receipts, verdict counts). An agent has enough to know when to call it and what to expect. No output schema exists, so return values are described at a high level only — adequate but not exhaustive.

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?

Zero parameters, so baseline is 4 per the rules. There are no parameter semantics to document, and the description correctly doesn't invent any. Nothing to penalize, but also no opportunity to exceed the baseline for a no-param tool.

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 verification action ('validating the local five-flagship golden workflow from source checkouts') and the resource is clearly the flagship workflow. It distinguishes itself from sibling doctor/status tools by specifying this is a golden-path validation across five specific source checkouts. It's clear what the tool does, though 'five-flagship golden workflow' is somewhat idiosyncratic terminology that only makes sense within this ecosystem.

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

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

The description provides a 'use when' trigger ('validating the local five-flagship golden workflow from source checkouts'), which gives clear usage context. However, it doesn't contrast with any of the ~40 sibling tools — there are many doctor/checker siblings (telos.doctor, telos.ci.doctor, telos.presentation.doctor, etc.) and the description never explains how this differs or when to pick it over them. The usage trigger is there but lacks the alternative differentiation the dimension rewards.

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 readOnlyHint, idempotentHint, non-destructive, and closed-world, so the safety profile is covered. The description's 'read-only, zero-auth, no external side effects' largely restates that, adding only the auth angle and the 'public-safe' guarantee — mild incremental value, but no disclosure of aggregation scope, latency, or result determinism.

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, front-loaded with the 'Use when' trigger and closing with the return shape. No filler, though the middle sentence partially duplicates the annotations.

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, the single line 'Returns a JSON workstation substrate register' is the only hint at results, and it does not say what the register contains or its granularity. For a zero-input read tool this is adequate to invoke, but not enough to know what the caller will receive.

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 takes no parameters, so there is nothing for the description to disambiguate and the baseline is 4. No misleading parameter claims are made.

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?

It names a resource (a 'workstation substrate register') and an implied action (registering/aggregating intake), but the phrasing is dense jargon ('public-safe aggregate intake', 'private/local lane families') rather than a specific verb+resource. It does not differentiate itself from near-neighbours like telos.admission.telemetry or telos.context.envelope, so an agent cannot confidently pick it over its many 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?

'Use when a host needs public-safe aggregate intake for local workstation repositories' gives a triggering condition, which is more than nothing. However, it names no alternatives and no exclusions (e.g. when to prefer telos.admission.telemetry), leaving the routing decision 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?

Goes well past the annotations with operationally critical detail: auth is X_BEARER_TOKEN, X bills each read and the receipt carries a cost estimate, per-host pacing with backoff on 429/503, a single User-Agent, no login, no cookies. That is exactly the kind of cost/rate-limit/auth context that annotations (readOnlyHint, openWorldHint) cannot convey.

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 dense sentences, front-loaded with the 'Use when...' trigger and then the cost/network profile. No filler, though the auth/cost/network sentence is packed and slightly long relative to the rest.

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, the description carries the return burden and does state 'Returns JSON and a receipt,' plus auth, billing, and network behavior. It is complete enough to call correctly, with only the receipt/JSON shape left unspecified.

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 80%, so the schema already documents id/query/username/max. The description adds semantic meaning by unpacking the three enum values (post, search_recent, user_posts) into plain-language operations, telling the agent what each op actually does beyond the bare enum tokens.

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?

Names a specific resource (X posts/user posts), a specific retrieval mode (post lookup, recent search, user's recent posts), and the provider (official X API v2). The 'official X API v2' scoping implicitly separates it from the sibling telos.x.oembed, so an agent can route without opening either 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 a clear activation condition (user has an X developer key) plus the three intended use cases, which map directly to the op enum. It stops short of explicitly naming the oembed sibling as the alternative when a developer key is unavailable, so the exclusion is only implied.

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

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

Annotations already declare read-only/open-world/idempotent-false, but the description adds substantial context they don't carry: zero-auth, no login/cookies, a single Telos User-Agent, and explicit per-host pacing with backoff on 429/503. It also discloses the return shape ('JSON and a receipt'), which matters since there is no output schema.

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

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

Front-loaded with the triggering condition, then scope exclusion, then behavioral/network facts, then the return note. Every sentence adds a distinct fact with no filler or redundancy.

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

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

Covers the essentials an agent needs: what it reads, auth posture, network/rate-limit behavior, and a brief return note. With no output schema the return description stays minimal ('JSON and a receipt'), which is a minor gap but not a blocker for a single-URL read.

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 single url parameter already documents the required format ('https://x.com/<user>/status/<id>'). The description only restates that input is the post URL, adding no syntax or constraint beyond the schema, so the 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 verb and resource ('needs the text, author and date of one public X post from its URL') and names the mechanism (X's public oEmbed endpoint). The 'no search or timelines' scope line implicitly separates it from the broader telos.x.api sibling, so an agent can distinguish it without opening a 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?

Front-loads a clear activation condition ('Use when an agent needs... one public X post from its URL') and gives a negative boundary ('no search or timelines'). It stops short of naming the alternative sibling (telos.x.api) explicitly, so the routing is implied rather than stated.

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