Project Telos

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

With no annotations, the description carries the full burden, and it delivers: 'Read-only, zero-auth, no external side effects' covers the safety profile, and it discloses the outcome vocabulary (MATCH, DRIFT, UNVERIFIABLE). It does not explain what distinguishes DRIFT from UNVERIFIABLE, leaving a small inference gap.

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

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

Three tight sentences with the trigger condition front-loaded, then safety profile, then return shape. No sentence is redundant and nothing is buried.

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 diagnostic with no output schema and no annotations, the description supplies everything an agent needs: when to invoke it, that it is safe and auth-free, and what the result tokens mean at a high level. Nothing material is missing.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. The description correctly adds no parameter noise, and instead spends its words on scope and return 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?

Specific verb (implicit 'diagnose' via doctor) plus resource (accessibility) and an enumerated scope: static HTML, reduced-motion, keyboard, and canvas-fallback checks. The scope is narrow enough to distinguish it from siblings like performance.doctor, compatibility.doctor, and presentation.doctor without opening any 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?

States the triggering condition explicitly ('Use when a host needs ... receipts for Telos Studio surfaces'), which is clear context. It does not name when-not to use it or point to an alternative sibling doctor, so it falls just short of the top band.

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

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

With no annotations provided, the description fully discloses behavioral traits: read-only, zero-auth, no external side effects. It also specifies the return type (JSON action-receipt interface), leaving no ambiguity.

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

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

The description is concise with two sentences, front-loading usage context and behavior. Every sentence provides necessary information without redundancy.

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

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

Given the zero parameters and no output schema, the description is complete. It covers purpose, usage, behavioral transparency, and return type, meeting all needs for this tool.

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

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

The input schema has zero parameters, so the description is not required to provide additional parameter details. The baseline of 4 applies as no param information 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?

The description clearly states the tool's purpose: modeling proposed action, admission, execution, review, and compensation records. It uses specific verbs and resources, and the context distinguishes it from the sibling tools by focusing on action receipts.

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

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

The description explicitly says 'Use when modeling...', providing clear context. It does not explicitly mention when not to use, but the use case is well-defined.

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

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

No annotations are provided, so the description carries the full burden. It discloses key behavioral traits: read-only, zero-auth, no external side effects. These are important for an AI agent to understand the tool's safety profile. The description does not contradict any annotations, and it adds value beyond 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?

The description is three sentences: first states usage, second states behavioral constraints, third states return type. Every sentence adds value, and there is no redundancy. It is front-loaded with the most critical information.

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

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

Given the tool's simplicity (no parameters, no output schema), the description is reasonably complete. However, it only vaguely states 'Returns a JSON telemetry convention' without specifying what fields or structure the convention includes. More detail about the return value would improve completeness for an AI agent.

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

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

The input schema has no parameters, and schema description coverage is 100%. According to guidelines, baseline for 0 parameters is 4. The description does not need to add parameter information, and it does not.

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

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

The description clearly states the tool's purpose: 'Use when designing trace fields that keep action admission separate from verification verdicts.' It identifies the resource ('telemetry convention') and the verb ('design'). However, it does not explicitly differentiate from sibling tools like 'telos.action.receipt' or 'telos.context.envelope', which may also deal with trace fields or telemetry.

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 explicit usage context ('Use when designing trace fields...') and lists constraints ('Read-only, zero-auth, no external side effects'). It does not mention when not to use the tool or suggest alternatives, but the given context is clear enough for an AI to decide when to invoke it.

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

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

No annotations are provided, so the description carries the full burden and does so well: it declares read-only, zero-auth, no external side effects, and that the returned packet is marked unredacted with URL and title retained. These are exactly the safety and provenance traits an agent needs, though it says nothing about determinism, size, or whether the fixture is stable across calls.

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 safety posture and return shape. Every sentence earns its place; the only minor drag is the slightly jargon-heavy first clause.

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 describe the return value, and it does at a useful level (JSON browser-evidence packet, unredacted, URL and title context). Given zero parameters and a simple read tool, that is nearly complete, with only the exact packet structure 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?

The input schema has zero parameters with additionalProperties=false, so there is no parameter semantics to explain and the baseline of 4 applies. The description correctly implies nothing is configured at call time.

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 and effect (a synthetic browser-evidence fixture returned for contract inspection), which is far more than a restatement of the tool name. It does not, however, differentiate itself from the many sibling fixtures (telos.proof, telos.proof.visual, telos.action.receipt), so an agent still has to infer where it sits in the family.

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 an explicit trigger context, which is real routing guidance. It stops short of naming when-not to use it or pointing at an alternative sibling, 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?

Without any annotations, the description fully discloses that the tool is read-only, requires zero authentication, and has no external side effects. It also specifies the output format (JSON catalog). This meets the transparency requirement for a zero-parameter tool.

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

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

The description is three concise sentences, front-loaded with the use case. Every sentence provides essential information without unnecessary verbosity.

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

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

For a zero-parameter, simple read-only tool with no output schema, the description covers purpose, usage, behavior, and return format completely. No gaps remain.

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 no parameters in the input schema, so the description does not need to add parameter details. The baseline is 4, and the description notes 'Return a JSON catalog', which aligns with the output.

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

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

The description explicitly states that the tool returns a provider-neutral catalog of Project Telos MCP tools and next actions. It uses specific verbs ('returns a JSON catalog') and distinguishes itself from sibling tools by its role as a catalog.

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

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

The description says 'Use when a host needs the provider-neutral catalog', providing clear context for when to invoke. While it does not explicitly list exclusions or alternatives, the context is sufficiently clear given the sibling tools represent distinct functions.

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

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

With no annotations present, the description carries the full safety burden and does so well: 'Read-only, zero-auth, no external side effects' explicitly declares the safety profile, which is the key trait an agent needs before calling. It does not cover error/determinism behavior or how verbose the register is, but for a zero-parameter diagnostic the disclosed traits are substantive.

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: trigger first, safety profile second, return shape third. The structure is well front-loaded, though the dense run of hyphenated jargon ('action-major', 'latest five-flagship') costs some readability.

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 annotations, no output schema, and no parameters, so the description bears the entire explanatory burden. It names the return type ('a JSON CI doctor register') but never says what the register contains or what a failing/passing receipt looks like, leaving the agent unable to interpret results. That is a real gap for a results-producing diagnostic.

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 defines zero parameters (additionalProperties: false), so there are no parameter semantics to explain and the baseline is 4. Nothing in the description contradicts or misdescribes the empty argument 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 identifies a specific resource: GitHub Actions runtime, action-major, and latest-flagship CI compatibility receipts, positioned as a diagnostic ('doctor') alongside sibling doctors like telos.presentation.doctor and telos.accessibility.doctor. The verb is only implied (it produces a register) and the phrase 'latest five-flagship' is opaque jargon, but an agent can tell this is a CI compatibility diagnostic rather than a general health check.

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?

An explicit trigger is given: 'Use when a host needs GitHub Actions runtime, action-major, and latest five-flagship CI compatibility receipts.' That is a clear usage condition rather than implied usage. It does not, however, distinguish this from the sibling telos.ci.triage or state any exclusion, 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?

With no annotations present, the description carries the full burden and largely meets it: it states read-only behavior, absence of external side effects and writes, two execution modes (zero-auth offline fixtures vs. live `gh run` intake using local gh auth), and the three possible receipt verdicts. It does not explain what MATCH/DRIFT/UNVERIFIABLE mean semantically, which is the main remaining gap.

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

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

Three sentences, all load-bearing: trigger, safety/auth profile, and return contract, with the usage trigger front-loaded. Slightly dense phrasing ('zero-auth offline fixture packets') costs a bit of readability but no sentence is 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?

With no output schema and no annotations, the description steps in to cover safety, auth requirements, and the shape of the return value, which is enough for a zero-parameter tool. An agent could still benefit from knowing what the verdicts imply or how the CLI modes are selected, but nothing essential to invocation is missing.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate beyond the schema. Baseline of 4 applies, and the description does not contradict or complicate 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 names a specific verb (separate/triage) and resource (GitHub Actions gate failures vs. Node runtime migration warnings), which is far more concrete than a tautology. It does not, however, differentiate itself from plausible siblings such as telos.ci.doctor, so sibling discrimination is left to inference.

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 to separate fatal GitHub Actions gate failures from Node runtime migration warnings before routing remediation" gives a clear trigger condition and workflow position. No explicit when-not conditions or named alternative tools are provided, so it stops short of a 5.

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

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

With no annotations, the description carries the full behavioral burden and does so well: it explicitly declares read-only operation, zero auth, and no external side effects, plus the three possible verdicts (MATCH, DRIFT, UNVERIFIABLE). It stops short of describing cost, latency, or what triggers UNVERIFIABLE, so it is strong but not exhaustive.

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 usage trigger and followed by the behavioral profile. 'Compatibility receipts' appears in both sentences, a minor redundancy, but nothing else 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, the essentials are covered: when to invoke it, that it is safe and unauthenticated, and what the three return states mean. Only the distinction from sibling doctor tools is absent, which keeps it short of fully self-contained.

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 4 applies; no parameter detail is needed or 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 scope: compatibility receipts covering CLI, MCP, protocol, manifest, and integration surfaces. It is clearly a diagnostic/verification tool, but it does not differentiate itself from the many sibling 'doctor' tools (telos.doctor, telos.ci.doctor, telos.presentation.doctor, etc.), leaving the agent to infer the domain split.

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 a host needs ... compatibility receipts' clause gives a clear trigger condition, which is a genuine usage cue. However, with roughly a dozen sibling doctor tools, no alternative is named and no exclusion ('use X instead for CI failures') is offered, so the routing decision 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 no annotations provided, the description fully discloses behavior: 'Read-only, zero-auth, no external side effects.' It also states the return format. This is comprehensive for a tool with no parameters or side effects.

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

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

Two concise sentences, each serving a purpose. The first sentence provides the use case, the second sentence declares behavioral traits and return type. No wasted words.

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

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

Given the tool has no parameters, no output schema, and simple read-only behavior, the description covers all necessary aspects: when to use, what it does, its side effects, and output format. It is fully complete for effective use.

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

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

The tool has zero parameters, so the input schema is fully covered (100% coverage). The description adds no parameter information, which is acceptable since there are none. Baseline score of 4 for zero-parameter tools.

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

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

The description clearly states the tool provides 'readable source refs, budgets, and receipt chains' for 'large-workspace context'. It specifies the return type (JSON context-envelope). While it doesn't explicitly distinguish from sibling tools like telos.context.pack, the purpose is specific and actionable.

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

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

The description begins with 'Use when...' providing explicit guidance on when to invoke this tool. It does not mention when not to use it or alternatives, but the context signal of sibling tools is available for the agent to compare.

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

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

Discloses key behaviors: read-only, zero-auth, no external side effects, and returns a validated JSON context pack. Without annotations, this description carries full burden and adequately informs the agent of safety and output.

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 concise sentences with front-loaded purpose. No unnecessary words; every sentence adds value.

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

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

Given zero parameters and no output schema, the description fully covers purpose, usage, behavior, and return format. An agent can correctly select and invoke this 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?

Input schema has no parameters, so baseline is 4. No need for additional parameter description; the tool's operation is self-contained.

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?

Clearly states the tool prepares a 'bounded handoff packet' for large-codebase agent work. The verb 'pack' and resource are specific, but it does not explicitly differentiate from sibling tool 'telos.context.envelope', which might serve a similar 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?

Explicitly says 'use when preparing a bounded handoff packet for large-codebase agent work,' providing clear context. Does not mention when not to use or alternative tools, but the purpose is well-defined.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It explicitly states 'Read-only, zero-auth, no external side effects,' which covers safety, authentication, and side-effect profile comprehensively. This is excellent transparency.

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

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

The description consists of two concise sentences. The first sentence front-loads the purpose and usage context, while the second adds key behavioral traits. Every sentence is necessary and no filler exists.

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

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

For a tool with no parameters and no output schema, the description provides sufficient context: it explains the tool's domain, that it returns a JSON manifest, and its behavioral traits. This fully equips an agent to invoke it correctly.

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

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

The tool has zero parameters, so the baseline is 4. The description adds value by explaining the return value ('JSON creative-engine manifest'), which is meaningful context beyond the empty 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 explicitly states the tool's function: presenting the Telos Creative Engine manifest across multiple creative lanes. It provides a specific verb ('presenting') and resource ('Telos Creative Engine manifest'), and distinguishes itself from siblings by listing the lanes and noting it's read-only.

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

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

The description opens with 'Use when presenting...' which implies the usage context. However, it does not explicitly state when not to use this tool or provide alternatives among the 21 sibling tools. This lack of explicit guidance reduces the score.

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

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

With no annotations, the description discloses key traits: 'Read-only, zero-auth, no external side effects.' This is good, but could mention output size or other constraints.

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

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

Single, concise sentence with front-loaded purpose. No wasted words.

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

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

Covers purpose, behavior, and return type for a read-only tool. Lacks detail on output format or limits, but sufficient given simplicity.

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

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

No parameters exist (schema coverage 100%). Baseline for 0 params is 4. Description implicitly confirms no inputs 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 clearly states the tool provides 'deterministic creative primitives' and lists specific use cases (dithering, pixel sorting, plotter paths, clustered-light bins), distinguishing it from siblings like telos.creative.engine.

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 'Use when deterministic creative primitives are needed,' providing clear context. However, it does not mention when not to use or name alternative tools, though siblings are listed.

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

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

With no annotations, the description discloses that the tool is read-only, requires no authentication, and has no external side effects. It also states the return format. However, it does not elaborate on the contents of the JSON 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?

The description is two sentences long, front-loads the purpose, and contains no unnecessary words. It earns its place efficiently.

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

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

Given no output schema and zero parameters, the description is adequate but lacks detail on the return value's structure beyond 'JSON display-calibration contract'. A bit more specificity would improve completeness.

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

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

There are zero parameters, so the baseline score is 4. The description does not need to add parameter information.

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

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

The description clearly states the tool provides a non-mutating calibration contract for display, color, ICC/LUT, artifact refs, or measurement gates. It is specific about the context, but does not explicitly differentiate from 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 explicitly says 'Use when' and lists conditions, also noting read-only, zero-auth, no side effects. It provides clear usage context but does not mention when not to use or alternative tools.

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

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

With no annotations, the description fully discloses key behaviors: 'Read-only, zero-auth, no external side effects, Returns JSON check results'. This is comprehensive for a simple tool.

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

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

The description is extremely concise at 21 words, front-loaded with usage context, and every sentence provides essential information without waste.

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

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

Given the tool is simple with no parameters and no output schema, the description covers the key aspects. It could be slightly more specific about what 'check results' entail, but it is mostly complete.

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

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

The tool has zero parameters, so per guidelines baseline is 4. The description does not need to add parameter info, and it doesn't.

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

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

The description clearly states the tool checks 'local Telos operator-spine health', which is a specific resource. It distinguishes from siblings like telos.status by focusing on operator-spine health. The verb 'check' is appropriate.

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

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

The description explicitly says 'Use before demos, listings, or agent runs', providing clear usage context. However, it does not mention when not to use or suggest alternatives, which is a minor gap.

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

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

With no annotations, the description carries the full burden and does a reasonable job: it declares read-only behavior, zero-auth, and no external side effects, plus the return format (a JSON packet). It stops short of idempotency or determinism guarantees, but the safety profile is explicit rather than inferred.

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, front-loading the usage trigger before the behavioral and return facts. Efficient, though the dense domain terms ('receipt-backed learning labs before synthesis') slightly obscure an otherwise tight phrasing.

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

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

For a zero-param tool with no output schema, the description covers purpose, trigger, safety, and return type. But given the very large sibling surface, it leaves the relationship to telos.learning.labs and the proof tools unexplained, which is the main remaining gap for correct tool selection.

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 (empty schema, additionalProperties false), so the per calibration baseline of 4 applies. There is nothing parameter-level for the description to explain 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 a domain resource ('receipt-backed learning labs') and an output ('JSON Learning Forge packet'), but the operative verb ('leads need to become...') is diffuse jargon rather than a clean verb+resource statement. It does not distinguish itself from the sibling telos.learning.labs, which an agent would have to disambiguate on its own.

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 supplies an explicit trigger ('Use when video, channel, paper, and benchmark leads need to become...before synthesis'), which implies pre-synthesis usage. However, it names no when-not conditions and no alternatives, even though telos.learning.labs and the telos.proof.* family are plausible competing choices.

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

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

With no annotations supplied, the description carries the full behavioral burden, and it does disclose the important traits: read-only, zero-auth, no external side effects, and that the result is a JSON packet. It omits softer traits such as determinism, whether labs are persisted, or idempotency on repeat calls, which prevents a 5.

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

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

Three short sentences, front-loaded with the trigger condition, and each sentence adds a distinct fact (when to use, safety envelope, return shape). The dense internal jargon costs readability, but there is no filler or repetition.

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 0-param tool with no annotations and no output schema, the description covers the essentials an agent needs: trigger condition, safety profile, and the return contract ('JSON Learning Forge labs packet'). The absence of any structural detail about the packet contents is acceptable given no output schema exists, but it leaves the result shape only nominally specified.

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

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

The tool takes zero parameters and the description introduces none, so there is no syntax or meaning to explain. Baseline for a 0-parameter tool is 4; nothing in the text misleads 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 names a concrete output (executable lab contracts with measurements, failure cases, and five-flagship ownership) built from a named input source (Learning Forge source leads), so an agent can tell what it produces rather than just restating the name. It does not explicitly contrast itself with the adjacent telos.learning.forge sibling, and the domain jargon ('five-flagship ownership', 'source leads') keeps it from being fully unambiguous, so it lands at clear-but-undifferentiated.

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' gives an explicit triggering condition tied to a sibling concept, which is real routing guidance. However, it names no alternative tool and gives no exclusions or 'when not to use' case, so it stops short of full when/when-not coverage.

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

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

With no annotations provided, the description fully bears the burden of behavioral disclosure. It clearly states the tool is read-only, requires no authentication, has no external side effects, and returns a JSON ledger. No contradictions.

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 succinct sentences with no superfluous words. The purpose, usage, and behavioral traits are front-loaded. Every sentence earns its place.

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

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

The tool has no output schema, so the description should explain the return value in detail. 'JSON loop-ledger convention' is too vague for an agent to know the structure or fields. Additionally, the description does not clarify what 'bounded scheduled runs' means or how the state is managed. More context is needed for a complete understanding.

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

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

The tool has zero parameters, so the input schema is fully covered. The description adds value by explaining the return type ('JSON loop-ledger convention'), which is helpful given the lack of an output schema. Baseline for 0 params is 4.

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

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

The description clearly states the tool is for durable state across agent loops and scheduled runs, with a specific verb ('loop ledger'). However, 'loop-ledger convention' is vague and could be more explicit, and sibling tools like 'telos.context.envelope' or 'telos.catalog' might also relate to state, but no differentiation is provided.

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

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

The description explicitly states when to use ('when an agent loop needs durable state'), implying read-only usage. It does not mention when not to use or list alternatives among the many sibling tools, but the context is clear enough for an agent.

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

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

Discloses read-only, zero-auth, no external side effects. Also describes return format (JSON with MATCH, DRIFT, UNVERIFIABLE). No annotations provided, so description carries full burden and does so thoroughly.

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

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

Two sentences with no wasted words. Front-loaded with use case, followed by behavioral traits and output. Extremely efficient.

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

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

Given no parameters and no output schema, description covers purpose, usage, behavior, and output states. Missing details on potential errors or edge cases, but sufficient for a simple read-only check.

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

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

No parameters in schema, so description naturally cannot add parameter details. Baseline for 0 parameters is 4; description is consistent and does not miss anything.

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

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

Description clearly states the tool's function: comparing loaded MCP servers against expected versions, tools, and probes. The verb 'compare' and specific resource 'freshness' make the purpose explicit and distinct from 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?

Explicitly says 'Use when a host must compare...', providing clear context. Does not mention when not to use or suggest alternatives, but the context is sufficient for an agent to decide.

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

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

Discloses read-only nature, zero authentication, no side effects, and return format (JSON measurement layers), compensating for missing 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 concise sentences that front-load the use case and quickly cover behavior, structure, and safety, with no wasted words.

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

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

The description adequately covers when to use, what it returns, and safety, despite lacking an output schema – sufficient for a simple 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?

No parameters exist, so the description adds context about the tool's purpose and return value, meeting the baseline for zero-parameter tools.

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

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

The description states the tool returns JSON measurement layers for specific evidence types (visual, splat, lighting, etc.), clearly distinguishing it from 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?

Explicitly says when to use (when evidence needs meters) and provides context (read-only, zero-auth, no side effects), though it does not mention when not to use or specific alternatives.

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

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

With zero annotations provided, the description carries the full burden and excels: it declares the tool is read-only, requires zero authentication, has no external side effects, and returns a JSON contract. This is complete and transparent.

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

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

Three concise sentences, front-loaded with the primary use case. Every sentence adds value with no redundancy or wasted words.

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

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

For a tool with no parameters and no output schema, the description provides every necessary detail: when to use, what it does, behavioral traits, and return format. It is 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 input schema has zero parameters and 100% coverage, so baseline is 4. The description adds significant meaning beyond the empty schema by stating the tool's usage context and return type, justifying a score of 5.

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

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

The description clearly states the tool's purpose: planning model-foundry work across multiple gates. It uses a specific verb ('planning') and resource ('model-foundry work'), and distinguishes itself from sibling tools by its unique domain and return type ('JSON model-foundry contract').

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

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

The description explicitly says 'Use when planning model-foundry work', providing clear guidance on when to use. However, it does not explicitly state when not to use or name alternative sibling tools for comparison, which would make it a 5.

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

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

With no annotations supplied, the description carries the full burden and does well: it declares read-only behavior, zero-auth, and no external side effects, plus the shape of the return (JSON capability and verb catalog). It omits rate limits, idempotency, and whether results are cached, so it stops short of fully rich 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 short sentences, with the usage trigger front-loaded ahead of the behavioral and return-value facts. Every sentence contributes, with only mild redundancy between the capability framing in sentence one and the return-value statement in sentence three.

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 supplies enough: what the catalog covers, that it is a safe read with no auth or side effects, and what comes back. Nothing critical to invoking it correctly is missing, though naming the sibling catalog tool would have closed the last 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 (empty object schema, additionalProperties false), so per the rubric the baseline is 4. There is no parameter syntax for the description to add, and it does not attempt to 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 names a specific resource — the Telos native background-control capability catalog — and scopes it to two concrete actuation domains (Chrome DevTools Protocol for browser, Windows UI Automation for native apps). It is clearly not a mutation or evidence tool, though the verb is implicit (retrieve catalog) rather than stated outright, and no sibling such as telos.catalog is explicitly distinguished.

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 ... capability catalog" states a clear trigger condition, so an agent knows the context that selects this tool. However, it offers no exclusions and does not name nearby alternatives (e.g., telos.catalog or telos.rendering.capabilities) that an agent might otherwise confuse with this one.

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

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

No annotations provided, but description fully discloses behavior: read-only, zero-auth, no external side effects, and returns JSON signals. Covers all critical behavioral aspects.

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 highly concise sentences, front-loaded with purpose. Every phrase adds value with no redundancy.

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

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

Given zero parameters and no output schema, the description sufficiently explains purpose, behavior, and return type. Complete for a simple monitoring 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?

No parameters exist, so schema coverage is trivial. Baseline for 0 parameters is 4; description adds nothing about parameters as none exist, which 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?

Clearly states it checks for drifting proxy metrics vs real objectives, with specific verb and resource. Distinguishes itself from siblings as 'objective monitor' among various telos 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?

Explicitly says 'Use when checking...' which provides direct guidance on when to invoke. No ambiguity about context.

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

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

With no annotations, the description carries the full burden and does well: it declares 'Read-only, zero-auth, no external side effects' (safety profile) and discloses the tri-state return vocabulary (MATCH, DRIFT, UNVERIFIABLE). It stops short of detailing what triggers DRIFT or how the receipts are scoped per artifact.

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

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

Three tight sentences, front-loaded with the 'Use when' trigger, then safety profile, then return values. No filler, though the artifact list in sentence one is a dense comma pile.

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 tool with no output schema, the description supplies the trigger, safety characteristics, and return-value vocabulary, which is sufficient for an agent to invoke and interpret it. Minor gap: it does not explain how this doctor differs in output from its sibling doctors.

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 baseline is 4; the schema is empty with additionalProperties false and the description correctly introduces no argument semantics.

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

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

States a specific diagnostic verb and resource (the Telos operator surface) and enumerates the artifacts it inspects: README, status, catalog, manifest, CI, and discoverability. This differentiates it from the many sibling doctor tools by naming the 'operator surface' scope, though it does not explicitly contrast with telos.doctor or telos.ci.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?

The 'Use when a host needs ... receipts' clause gives a trigger condition, but offers no when-not guidance and names no alternatives among the numerous sibling doctor/diagnostic tools, leaving the agent to infer the boundary itself.

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

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

With no annotations at all, the description carries the full burden and does well: it discloses read-only behavior, zero-auth, no external side effects, and the shape of the output verdicts (MATCH, DRIFT, UNVERIFIABLE). It stops short of explaining what triggers DRIFT versus UNVERIFIABLE or any cost/rate considerations.

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 then the safety/return profile. Dense and largely jargon ('receipts'), but every clause contributes and nothing is padded.

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

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

There is no output schema, so the description appropriately fills the gap by naming the possible verdicts. For a zero-param, read-only diagnostic tool this is nearly complete; only the meaning of the verdict states is left implicit.

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 describe and the baseline of 4 applies. Nothing in the description is needed to clarify 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 names a specific diagnostic domain (static Studio performance, efficiency, asset-budget, and embedding receipts) with a clear verb sense from 'doctor' that is established by the sibling convention. It implicitly distinguishes itself from the many other *.doctor tools by domain scope, though it never explicitly contrasts 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 needs static Studio performance... receipts' gives a clear triggering condition, but there is no when-not guidance and no named alternative among the ~15 sibling *.doctor tools (ci.doctor, accessibility.doctor, compatibility.doctor, etc.). Usage is implied rather than routed.

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

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

With no annotations, the description carries the full burden and does meaningful work: it declares the tool read-only, zero-auth, with no external side effects, and discloses the return vocabulary (MATCH, DRIFT, UNVERIFIABLE). It does not describe comparison scope or failure modes for UNVERIFIABLE, but the safety and output profile is well covered.

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 followed by the safety profile and return values. Every sentence carries distinct information and there is 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, annotation-free diagnostic with no output schema, the description supplies the essential pieces: trigger, safety posture, and result categories. It stops short of explaining what a DRIFT receipt contains or what 'five-flagship' scoping means, which leaves minor gaps.

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

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

The tool takes zero parameters, so schema coverage is vacuous and the baseline of 4 applies. Nothing in the description is needed to explain arguments, and none are misleadingly implied.

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 domain (presentation parity across README, changelog, and brand assets) that clearly distinguishes it from sibling doctors like telos.ci.doctor, telos.accessibility.doctor, and telos.performance.doctor. The verb is implicit in the 'doctor' naming and the generic 'Use when' opener, and 'five-flagship' is unexplained jargon, keeping it short of a clean 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 one trigger condition ('Use when a host needs ... presentation parity receipts'), which is a real usage cue. However, with seven other doctor-style siblings in the roster, there is no guidance on when to prefer this over them and no exclusions, so selection still requires inference.

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

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

With no annotations, the description carries the full burden and does step up on the safety profile: it declares read-only, zero-auth, and 'no external side effects beyond local subprocess reads.' That is genuinely useful. It stops short of disclosing idempotency, error behavior, or what a local subprocess read implies operationally.

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 when-to-use clause is sensibly front-loaded, but the middle sentence is a comma-chained jargon inventory ('source refs, context refs, route, admission, side effects, output digests, verifier checks, and the Emet witness stage') that adds bulk without clarifying scope. It is not bloated, but it is not tight either.

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-arg, no-annotation, no-output-schema tool, the description does confirm the return is a JSON proof packet and states the safety profile. What it omits — how this differs from the three sibling proof tools and what the witness/admission stages mean — leaves real gaps against the family'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?

The tool takes zero parameters, so there is no parameter semantics to document and the baseline is 4. The description does not fabricate or contradict any argument 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?

States a recognizable resource ('agent-action proof packet') and lists the artifacts it joins, so the general intent is clear. However, no sibling is distinguished — telos.proof.research, telos.proof.visual, and telos.proof.build likely operate in the same space, and the heavy jargon ('Emet witness stage', 'route, admission') obscures what uniquely defines this variant.

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 a host needs...' clause gives an implied trigger context, which is more than nothing. But there is no when-not guidance, no named alternatives, and no distinction drawn from the telos.proof.* siblings, so an agent given a proof request cannot tell which of the four to 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?

With no annotations, the description carries the full burden and delivers: read-only, zero-auth, no external side effects beyond local subprocess reads, and details the internal recomputation and required negative fixture. This is thorough behavioral disclosure for a tool with no structured safety hints.

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 first sentence is a dense run-on packing many technical clauses, making it hard to parse. It is front-loaded with the use condition, but could be split for better clarity and readability.

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

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

The description states it returns a JSON build proof packet but gives no detail on packet structure, and with no output schema this leaves the agent guessing about the return format. It otherwise covers purpose and behavior adequately for a zero-parameter tool.

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

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

No parameters exist, so the baseline is 4. The description adds no parameter information, which is appropriate given the empty input 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?

States the specific resource (fixture-backed build scientific-runtime proof packet) and its key computed elements (conserved-quantity invariant and conservation drift), distinguishing it from generic proof siblings by the scientific-runtime and build qualifiers. However, it does not explicitly contrast with telos.proof.research or telos.proof.visual, leaving sibling differentiation 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?

Provides a clear condition for use ('Use when a host needs...') but does not name alternatives or state when not to use it. The condition is specific to this tool's output, giving 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?

With no annotations, the description carries the full safety burden and does state the key traits: read-only, zero-auth, and no external side effects beyond local subprocess reads. That is solid disclosure of the safety profile, though it omits failure modes, idempotency, and any cost/latency expectations.

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

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

Two sentences, the trigger condition front-loaded ahead of the safety and return notes. The first sentence is a heavy comma-list that is hard to parse, but there is 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?

With no output schema, the description must convey the return value and does ('Returns a JSON research-claim proof packet'), reinforced by the enumerated components. It is nearly complete for a zero-param read tool, though it leaves the meaning of some packet fields unexplained.

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

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

The tool takes zero parameters, so the baseline is 4. There is nothing for the description to disambiguate, and the empty schema with additionalProperties:false is self-consistent with the described behavior.

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

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

The description names a specific artifact (a fixture-backed research-claim proof packet) and enumerates the pieces it joins, which distinguishes it from generic siblings like telos.proof and telos.proof.visual. However, the dense jargon ('promotion rung the verifier derives rather than trusts') makes the core verb ambiguous, and it never explicitly contrasts itself with the other proof 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 opens with a trigger phrase ('Use when a host needs...'), giving implied usage context. There is no when-not guidance and no routing to alternatives, so an agent still cannot tell from this text alone whether to pick this over telos.proof, telos.proof.build, or 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?

With no annotations provided, the description carries full burden and does disclose the key traits: read-only boundary, zero-auth, no external side effects beyond local subprocess reads, and a no-physical-calibration-overclaim scoping constraint. It stops short of describing return-packet fields or runtime/fixture requirements, so it is good but not exhaustive.

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 and the safety boundary. The first sentence is dense with jargon ('fixture-backed visual-truth proof packet... embedded sRGB samples') but each clause contributes scope or behavior rather than 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 tool with no output schema and no annotations, the description covers what is produced ('Returns a JSON visual-truth proof packet') and the safety profile. It does not enumerate packet contents or fixture prerequisites, but nothing essential for correct invocation is missing.

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

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

The tool takes zero parameters, so there is no per-parameter meaning for the description to add. Baseline 4 applies; nothing more is warranted.

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 — a 'fixture-backed visual-truth proof packet' — with color/luminance measurements recomputed from embedded sRGB samples, and the 'no physical-calibration overclaim' qualifier implicitly separates it from calibration siblings. The verb is implied rather than stated ('Use when a host needs...'), but an agent can tell this apart from telos.proof.research and telos.proof.build.

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

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

It gives a usage trigger ('use when a host needs the fixture-backed visual-truth proof packet'), which implies scope, but never names an alternative tool or a when-not condition. The boundary against telos.display.calibration and the other proof siblings must be inferred.

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

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

Discloses read-only, zero-auth, and no external side effects directly in description, compensating for absent annotations. Also mentions return format (JSON renderer 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?

Two sentences with zero waste. First sentence front-loads usage purpose, second covers behavioral transparency and output. Every sentence earns its place.

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

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

Given zero parameters, no output schema, and simple purpose, the description fully covers what the tool does, its side-effect profile, and return type. No gaps remain.

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

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

No parameters exist (schema coverage 100%), so baseline 4 applies. Description adds value by explaining the return value type and purpose, which is meaningful beyond the empty 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?

Clearly states the tool is used to choose rendering fallbacks (WebGPU, WebGL, canvas, static) for Studio surfaces. Distinguishes from sibling 'telos.rendering.research' by focus on capability contract vs. 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?

Explicitly states when to use: 'Use when a host must choose...fallbacks'. Provides clear context for usage without needing exclusions or alternatives beyond sibling list.

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?

Despite no annotations, the description fully discloses key behavioral traits: read-only, zero authentication needed, no external side effects, and returns JSON. This is comprehensive for a safe, stateless 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?

Two sentences, no waste. Front-loaded with usage context, followed by behavioral traits and output format. Every sentence earns its place.

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

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

Given no output schema, zero parameters, and no annotations, the description fully covers what an agent needs: purpose, safety, auth requirements, and return value type.

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

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

Input schema has zero parameters and 100% coverage. No additional parameter information is needed. The description adds no param-level details, but the baseline for zero-param tools is 4.

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

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

The description specifies a clear and unique purpose: collecting rendering leads for specific domains (clustered-forward, Gaussian splatting, creative coding, graphics demos). It distinguishes from sibling tools like telos.rendering.capabilities by focusing on research leads.

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 states when to use ('when collecting rendering leads...'). While no exclusions or alternatives are mentioned, the domain is specific enough to guide usage without confusion.

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?

Without annotations, the description covers key behavioral aspects: 'Read-only, zero-auth, no external side effects,' and describes the return type. It could add more detail on internal operations, but currently sufficient for the tool's simplicity.

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

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

The description is two sentences, front-loading the use case, and every word adds value. No redundancy or verbosity.

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

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

The description provides sufficient context given the tool has no parameters, no output schema, and the sibling tools list. It clearly explains when to use and what to expect, leaving no major gaps.

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

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

With zero parameters, the schema offers no additonal meaning. The description compensates by explaining the tool's operation and output, earning the baseline of 4.

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

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

The description explicitly states the tool's purpose: creating 'source-backed seed packets' from 'terse research notes before synthesis.' It distinguishes itself from siblings by specifying the context and output type.

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 begins with 'Use when...', providing clear guidance on when to deploy this tool, referencing the specific scenario of needing source-backed seed packets before synthesis.

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

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

Discloses read-only, zero-auth, no side effects, and output format. No annotations provided so description carries full burden and excels.

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 use case, no wasted words.

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

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

Fully describes behavior, inputs, and output for a simple research tool. No gaps given zero parameters and no output schema.

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

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

Zero parameters; schema coverage 100%. Description confirms no inputs needed, which is sufficient.

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

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

Clearly states purpose: exploring thermodynamic or stochastic AI-chip research via public transcript evidence. Differentiates from siblings by specifying domain.

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 states when to use (exploring specified research). While no direct exclusions, the context implies alternatives for other research.

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

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

With no annotations provided, the description fully bears transparency. It discloses read-only, zero-auth, and no external side effects, which are crucial for safe invocation. It also states the return type (JSON revival registry), though details of the registry structure are omitted.

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

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

Two sentences, front-loaded with the key use case. No redundant information. Every sentence is essential: purpose, behavioral traits, output format. Excellent conciseness.

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

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

Given zero parameters and no output schema, the description provides sufficient context: purpose, usage guidance, safety, and return type. It could be improved by describing the registry's contents, but overall it is adequate for an agent to decide usage.

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

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

The tool has zero parameters and schema coverage is 100%. The description adds no parameter information, which is acceptable as there are none. Baseline score of 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 clearly states the tool's purpose: to help decide which older, siloed, or frozen local tools should be promoted into flagship lanes. It specifies the resource (revival registry) and distinguishes from siblings by its focus on revival. However, it could more explicitly state that the tool returns the list of candidates.

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

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

The description explicitly says when to use: when deciding which tools to promote. It also notes the tool is read-only and zero-auth, indicating safe usage. No alternatives or when-not scenarios are mentioned, but the sibling context implies differentiation.

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

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

With no annotations, the description carries the full burden and does so well: it declares read-only, zero-auth, the exact sibling checkouts and interpreter required, and the failure behavior (an UNVERIFIABLE envelope naming the missing dependency instead of a live summary). That failure-path disclosure is unusually valuable for an agent deciding whether to call it.

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, front-loaded with the trigger condition, then the safety/prerequisite envelope, then the return shape. No padding, though the prerequisite list is dense enough to slow scanning.

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

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

For a zero-parameter read-only tool with no output schema, the description covers trigger, safety profile, prerequisites, failure mode, and return type ('JSON action envelope'). The only omission is any hint of the summary's fields or freshness, which is minor.

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 are no argument semantics to add. The description correctly implies no inputs are needed by naming all prerequisites as environmental rather than call 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?

It states a concrete retrieval action (returning the current five-flagship room summary) rather than restating the name. The scope is specific and the 'before routing work' framing distinguishes it from catalog/status siblings, though the term 'five-flagship room summary' remains somewhat jargon-dependent.

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 an agent needs ... before routing work' gives a clear trigger condition, which is more than most siblings offer. It does not name an explicit alternative tool for when the summary isn't needed, so it stops short of full when/when-not 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?

With no annotations provided, the description carries the full burden and does so credibly: 'Read-only, zero-auth, no external side effects' are exactly the traits an agent needs before calling an unknown-namespace tool, and it states the return is a JSON queue. It omits details like whether results are paginated, cached, or scoped by any implicit context.

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

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

Three short sentences, each earning its place: trigger, safety profile, return type. Front-loaded with the usage condition and zero 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, read-only tool with no output schema and no annotations, the description supplies the safety profile and return type an agent needs to invoke it safely. The main residual gap is that it never defines the domain concept 'second-level flagship', which leaves the agent guessing about the substance of the payload.

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 4 applies; no parameter-level information 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?

The description names the resource ('second-level flagship queue') and its role ('before registry promotion'), which hints at a sibling boundary with telos.revival.registry. However, the domain jargon 'second-level flagship candidates' is undefined, so an agent cannot confidently say what the queue actually contains or what 'assessing' entails.

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 assessing public-safe second-level flagship candidates before registry promotion.' That is a clear when-to-use signal. It stops short of naming alternatives or exclusions, so it does not reach a 5.

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

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

With no annotations provided, the description carries the full burden. It explicitly states the tool is read-only, requires zero authentication, and has no external side effects. This provides complete behavioral transparency.

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

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

The description is extremely concise with two sentences. The first sentence front-loads the usage context, and the second adds behavioral traits and return type. Every sentence earns its place.

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

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

Given no parameters and no output schema, the description sufficiently covers purpose, usage context, behavioral traits, and return type. It is complete for this simple parameterless 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 has zero parameters, so the baseline score is 4. The description does not need to add parameter semantics, and it correctly omits any parameter details.

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

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

The description clearly states the tool returns a JSON server manifest and specifies the exact use case: configuring MCP clients for gather, index, forum, crucible, and telos source checkouts. This distinguishes it from sibling tools by providing a specific context.

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

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

The description explicitly states when to use the tool ('when configuring MCP clients...'), providing clear context. It does not mention when not to use or alternatives, but the specificity makes it adequate.

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

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

With no annotations provided, the description carries the full burden and does disclose the key safety traits: read-only, zero-auth, no external side effects. It also states the return type (JSON scout results). It omits determinism, fixture-availability failure modes, and whether results are cached or stable across calls.

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 waste; the trigger condition is front-loaded and the safety profile and return type follow. Every sentence earns its place.

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

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

For a zero-param, no-output-schema read tool, the description covers the trigger, the safety envelope, and the return type. The only gap is that 'JSON scout results' leaves the response shape unstated, which matters slightly given there is no output schema to fall back 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, so there are no parameter semantics to document; the baseline for a parameterless schema is 4. Nothing in the description contradicts or misrepresents the empty input 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 the specific artifact produced — fixture-backed OSS Proof Showcase candidate rankings — which is distinct from sibling proof/rendering/measurement tools. The verb is implied rather than stated ('scout'), but the resource and output are concrete enough for an agent to identify the tool's role.

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 a host needs fixture-backed OSS Proof Showcase candidate rankings before public patch work,' which also encodes ordering relative to patch work. No alternatives or exclusions are named, 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?

No annotations provided, so description carries full burden. It explicitly states 'Read-only, zero-auth, no external side effects' and 'Returns a JSON action envelope', fully disclosing behavior without contradictions.

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, each earning its place: usage context, behavioral traits, return format. No wasted words, front-loaded with key 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 parameterless tool with no output schema, the description fully covers purpose, usage, behavior, and return type. No gaps.

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

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

No parameters exist, schema coverage is 100%. Baseline is 4, and description adds no param info but provides context on return format, which is adequate.

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

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

The description clearly states the tool returns current Telos workbench readiness and next actions. It uses a specific verb ('returns') and resource ('readiness and next actions'), distinguishing it from sibling tools like 'telos.doctor' or 'telos.workflow'.

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

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

Explicitly says 'Use when a host needs current Telos workbench readiness and next actions', providing clear context. While it doesn't exclude other tools, the sibling names imply distinct purposes, and the description is sufficient for a simple status check.

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

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

With no annotations present, the description carries the full behavioral burden and does so well: it declares read-only and zero-auth operation, bounds side effects to local subprocess reads, enumerates hard prerequisites (sibling gather/crucible/index/forum checkouts plus a local python interpreter), and specifies the failure mode (an UNVERIFIABLE envelope naming the missing dependency rather than running). That is exactly the disclosure an agent needs before invoking.

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-loads the usage condition, then preconditions, then failure behavior, then return shape — a sensible priority order with little waste. It is dense with compound clauses, but each sentence carries distinct 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?

No output schema is present, so the description must (and does) sketch the return value: JSON receipts and verdict counts. Combined with the prerequisite and failure-mode disclosure, an agent has everything needed to decide whether this call can succeed.

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 per the rubric the baseline is 4. There is nothing for the description to add, and it correctly does not invent parameter guidance.

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 (validating) and resource (the local five-flagship golden workflow from source checkouts), so an agent can tell it is a validation runner. It does not, however, differentiate itself from any of the many sibling telos.* doctor/status/ci tools, and 'five-flagship golden workflow' is jargon an agent must already understand.

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 triggering condition ('Use when validating the local five-flagship golden workflow from source checkouts'), which is a clear when-to-call context. It names no alternatives and gives no when-not, so it falls short of the top band.

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

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

With no annotations, the description carries the full burden — and it does declare the important traits: read-only, zero-auth, no external side effects, and a JSON return shape. This is a genuinely useful safety/auth disclosure, though rate limits, error behavior, and scope of what the register contains are unstated.

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 trigger front-loaded and the safety/return facts following. No filler, though the dense internal jargon slightly reduces immediate legibility.

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, so the description must characterize the return value; it only says “JSON workstation substrate register” without what fields or aggregates it contains. Read-only status is covered, but an agent still can't predict the response payload.

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; the 0-parameter baseline 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 identifies the resource domain (“local workstation repositories and private/local lane families”) and the output (“JSON workstation substrate register”), but the core action is vague jargon — “aggregate intake” and “substrate register” don't tell an agent plainly what operation is performed. It is distinguishable in flavor from siblings like telos.proof or telos.ci.doctor, but not by a concrete verb+resource.

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

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

“Use when a host needs public-safe aggregate intake…” supplies a use condition, which is more than nothing. However, no alternative sibling tool is named, and no exclusion condition is given, so the agent must guess whether this or telos.catalog/status covers its need.

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