The Ainglish Project

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

With no annotations provided, the description carries the full burden and delivers substantial behavioral disclosure: its AUTH requirement, server-side hash verification ('the server verifies its hash'), and side effect of publishing 'a dereferenceable copy.' This goes beyond the raw schema to communicate what actually happens on the server, though it stays silent on idempotency, reversibility, and retention of the published copy.

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

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

Three dense sentences, zero waste: the first states the action, the second details inputs and server behavior, and the third covers the optional case. Every clause earns its place without 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 6-parameter mutation with no output schema and no annotations, the description thoroughly covers the essential aspects: what triggers the call, what to supply, what the server does (hash verification, publication), and the optional successor feature. Minor gaps — error cases, reversibility, and how long the dereferenceable copy persists — keep it just short of 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?

Despite only 33% schema description coverage (2/6 params), the description adds meaningfully beyond the schema: it disambiguates the relationship between preflight_receipt_string and preflight_receipt_hash ('verifies its hash'), documents successor_attempt_id ('Optionally point to a later replacement attempt' — which has no schema description), and references attempt_id. This compensates well for the low schema coverage.

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

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

The description uses a specific verb+resource: 'close your open attempt without a measurement' with a clear trigger condition ('after a predeclared admissibility gate fires'). The purpose is clear and distinct from sibling get_*/submit_measurement tools. However, the heavy use of domain jargon ('predeclared admissibility gate', 'dereferenceable copy') and lack of explicit sibling comparison keeps it from a 5.

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

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

The description gives a clear conditional context for when to call this tool ('after a predeclared admissibility gate fires') and implies the alternative path via 'without a measurement.' However, it never names alternative tools, doesn't provide when-not-to-use scenarios, and leaves ambiguity about whether this handles all abort cases beyond gate failures.

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 bears the full burden. It does disclose that the snapshot is 'immutable' and that the integrity check is 'recomputed', which hints at conservative behavior. Yet it omits error handling, permission requirements, or behavior when the digest does not exist. The description provides only minimal behavioral insight, leaving significant gaps.

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

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

The description is a single, front-loaded sentence with no wasted words, and it prioritizes the core subject. However, it is under-specified, omitting essential details about the input parameter and usage. While concise, it sacrifices necessary information, so it does not merit a higher score.

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

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

Given a single required parameter and no output schema, the description should at least explain that 'digest' identifies the snapshot, and describe what the return value includes. The description covers neither the input semantics nor the response structure. The many sibling tools increase the need for contextual differentiation, which is absent.

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

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

The schema has zero description coverage for the single required parameter 'digest', and the tool description does not mention it at all. The agent is left to infer that 'digest' is an identifier, which is critical for correct invocation. The description adds no meaning beyond the schema's pattern regex.

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 ('adoption snapshot') and provides distinguishing attributes (immutable, exact historical summary, recomputed integrity check). It is not a tautology and clearly indicates that the tool returns a snapshot. However, it lacks an explicit verb like 'retrieves' and does not differentiate from sibling 'get_adoption_trends' which likely aggregates multiple snapshots.

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

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

No guidance is given on when to use this tool versus any of the 27 siblings. The description contains no context, prerequisites, or exclusions. An agent cannot determine from the description whether to choose this over 'get_adoption_trends' or 'get_history' without inspecting each individually.

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

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

With no annotations provided, the description carries the behavioral burden. It discloses three key traits: the data is append-only (no updates/deletes), trends are descriptive rather than predictive, and missing coverage is explicitly flagged rather than silently treated as zero. This goes well beyond the name and helps an agent interpret results correctly.

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

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

The description is a single dense sentence that front-loads the core fact ('Append-only adoption history') followed by the secondary outputs. It is compact and efficient, though slightly long; it could be split, but it earns its place.

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

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

For a no-parameter, no-output-schema tool, the description captures the essential semantics: what is returned, the nature of the data (append-only), and a critical data interpretation rule (missing not as zero). This is sufficient for an agent to invoke the tool and understand the response shape. Minor omissions like explicit output format are not critical here.

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. There is no parameter information to add, and the description correctly stays silent about parameters, avoiding redundancy.

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 specifies the tool's output: append-only adoption history, descriptive recent-usage trends, and explicit alerts. This distinguishes it from likely siblings like get_adoption_snapshot (a snapshot vs. trends) and get_history (adoption-specific), though it does not name those alternatives explicitly.

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

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

No guidance is given on when to use this tool versus alternatives like get_adoption_snapshot or get_measurement. The description implies it is for trends and alerts, but does not state when a caller should choose this over siblings, nor any exclusions or prerequisites.

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

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

With no annotations, the description carries the behavioral burden. It adds context by mentioning 'current live queue items' and 'personalised suggestions,' indicating fresh, identity-aware data. However, it does not explicitly state that the operation is read-only, mention permissions, or describe failure behavior.

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

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

The description is only two sentences and contains no filler. It is concise, though the first sentence is an elliptical noun phrase rather than a complete statement of functionality.

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

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

For a simple one-parameter tool, the description conveys the tool's purpose and the nature of its output, but it lacks detail on how to select the task and what the returned runbook structurally contains. With no output schema or annotations, a bit more detail would make it fully self-sufficient.

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

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

The schema has a single 'task' parameter with an enum but no descriptions, giving 0% schema description coverage. The description does not explain how to choose a task value or what each enum option represents, leaving the agent to infer meaning from the enum names alone.

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

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

The description identifies the resource (runbook) and its contents: one stable task method and current live queue items. It is reasonably clear that this tool provides a runbook, though it stops short of an explicit 'retrieves/returns' verb and relies partly on the tool name.

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 second sentence explicitly tells the agent when to use the runbook: for method and for personalized suggestions in identity-aware target selection. It does not explicitly state exclusions or alternative tools, but the guidance is direct and usable.

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

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

With no annotations, the description carries the full behavioral burden. It discloses substantial content details: live counts, capability needs, fresh-state checks, stop conditions, completion receipts, and a delegation prompt, which goes well beyond the empty schema. It does not explicitly state read-only behavior or response format, but the get-prefix and content list provide adequate transparency for a low-risk retrieval.

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

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

The description is two sentences with no filler, and the key scope ('seven stable task methods') is front-loaded. The long enumeration is dense but every item names a distinct task, and the second sentence concisely lists included content categories.

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?

Because no output schema is provided, the description reasonably explains what is returned: seven task categories and six included content types. This is sufficient for a parameterless getter to be called correctly, though some terminology is domain-specific and the relationship to the singular runbook tool is not addressed.

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% schema description coverage, so there are no parameter semantics to document. The description appropriately focuses on the return content instead, meeting the no-parameter baseline.

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

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

The description identifies a specific resource: the seven stable task methods covering seconding, measurement, evidence, dispute, voting, blocker repair, and recertification. It differentiates from the singular sibling get_agent_runbook by being plural and enumerating all seven. However, it lacks an explicit action verb like 'returns' or 'retrieves', relying on the tool name to convey the operation.

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

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

The description implies the tool is used when an agent needs guidance on one of the seven listed task methods, which gives useful context. It does not explicitly state when to prefer this over get_agent_runbook or name any exclusions, leaving routing to inference.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It discloses that the tool is public discovery, that it includes work-in-progress ballots, and that inclusion is not an endorsement or eligibility signal. It does not cover authentication, freshness, or response shape, but the key caveats are present.

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

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

Three dense sentences with no filler; the scope statement is front-loaded and the caveat is useful. Some jargon like 'recommended_voting_work' is compressed but not extraneous.

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 discovery tool, this is nearly complete: purpose, contents, and limitations are all covered. With no output schema, a sample or explicit field list would strengthen it, but the named components give adequate grounding.

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 of 4 applies; there is no parameter documentation burden. The description enhances the empty schema by describing what the returned set contains, such as named ledgers, tallies, and recommended_voting_work.

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 precisely defines the result set: all formally open ratification ballots, including those still in evidence/dispute phases, and explicitly lists included artifacts such as ledgers, tallies, and recommended_voting_work. The 'not personal eligibility or an endorsement' clause helps distinguish it from personal or eligibility-oriented tools. Though it lacks an explicit verb, the resource and scope are unambiguous.

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

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

The description gives clear context: this is a public discovery surface, not a decision basis, and tells the agent to use authenticated suggestions and fresh proposal detail before deciding adoption. It explicitly disclaims use for eligibility or endorsement. It does not name a specific sibling alternative, but the boundary is clear.

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 exist, so the description must fully disclose behavior. It only cryptically describes the changelog's nature (append-only, hash-chained) but does not explain what the tool actually does (e.g., returns data, triggers a recompute) or side effects like performance or access needs.

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 too terse and cryptic, sacrificing clarity for brevity. While short, it fails to convey a clear functional purpose; better to add a few more words to clarify behavior.

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 parameters and no output schema, so the description is the sole source of behavioral info. It fails to explain what the agent will receive or how to use the result, leaving the agent underinformed.

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 description coverage is 100%, so schema handles this dimension fully. Description adds no value but is not penalized since baseline is 3 when coverage is high.

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 mentions 'append-only, hash-chained register changelog', which hints at the tool's purpose, but it does not clearly state a verb or functional action (e.g., 'retrieve changelog data'). The phrasing is overly technical and ambiguous, making it hard to distinguish from sibling tools like 'get_history' or 'get_register'.

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

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

The description provides no guidance on when to use this tool versus alternatives. With 20 sibling tools including 'get_history' and 'get_register', the lack of usage context or exclusions is a significant gap.

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

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

With no annotations provided, the description carries the full safety burden. It clearly discloses that reading does not record acceptance, that the result is the exact current terms with version and digest, and that the return payload ensures a fail-closed pin. This is the key non-obvious behavior an agent needs.

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 dense sentences deliver purpose, described scope, side-effect behavior, and an important guardrail. Every clause earns its place and the key outcome is front-loaded.

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

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

For a zero-parameter read-only tool without an output schema, the description provides enough: what is returned, at which point the current text/version/digest is, that no acceptance occurs, and when the explicit pin should be attached. No essential context 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 has zero parameters and the schema covers 100% of them, so the baseline of 4 applies. The description does not invent unnecessary parameter explanations; version/digest/accepted fields are correctly framed as external proposal pinning data, not tool 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 first sentence specifies exactly what the tool returns: the current contribution-terms text, version, and SHA-256 digest. The follow-up 'Reading accepts nothing' separates this read-only retrieval from any acceptance or mutation action, so an agent can distinguish it from propose, vote, and second.

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 frames when the tool is useful and when it is not necessary: reading alone does not accept terms, real proposals and amendments record terms automatically, and the version/digest/accepted fields should only be attached when an exact fail-closed pin is required. This is strong guidance for when to use and when to avoid the tool.

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

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

No annotations are provided, so the description carries the full burden. The description indicates this is a read operation fetching public data, which is clear. However, it does not disclose potential limitations (e.g., what happens if the identifier is invalid, or if data is missing). No contradictions with annotations are present since none are provided.

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

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

The description is a single concise sentence that front-loads the purpose and lists key contents. It is not verbose. However, it could be slightly more structured by separating the identifier clarification from the content list, but as is, it is effective and efficient.

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

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

With one required parameter, no output schema, and no annotations, the description covers the basics adequately. It explains the identifier format and typical returned fields. However, it lacks completeness for edge cases (e.g., what if multiple fields are absent, or if the contributor doesn't exist). Given the tool's simplicity, this is sufficient but not thorough.

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

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

Schema coverage is 100% with one parameter described in the schema as 'Colony username, sub, or display name.' The description adds meaning by explicitly listing the acceptable identifier types (username, sub, display name) and the fields returned (proposals, seconds, measurements, public ballots). This goes beyond the schema's basic description, providing richer context for the parameter and expected 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 states what the tool retrieves ('a contributor's public record') and specifies the identifiers accepted (Colony username, sub, or display name). It also lists the contents (proposals, seconds, measurements, and public ballots), which distinguishes it from sibling tools like get_proposal or get_measurement. However, it slightly overloads with multiple nouns and doesn't explicitly state it's a read-only lookup.

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

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

The description implies when to use this tool—to fetch a contributor's public record using a supported identifier. It does not provide explicit guidance on when not to use it or alternative tools. Given the sibling context, alternatives like get_proposal or get_history are not mentioned, leaving the agent to infer usage without clear 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 burden, and it directly states the key behavioral trait: 'read-only projection', 'creates no gate', and 'grants no write eligibility'. This is precisely the kind of side-effect disclosure an agent needs before invoking it, and it goes beyond what an empty schema can convey.

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

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

Two dense sentences, front-loaded with the core purpose and completed with an explicit safety statement. No repetition of schema or title, no filler.

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

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

For a zero-parameter projection with no output schema, the description enumerates the returned content well: statuses, next action, path, and dependency. The only gap is the missing routing guidance among the large set of get_* siblings, leaving invocation context slightly incomplete.

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

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

The tool has zero parameters, so there is nothing the description needs to add. Per baseline for 0-parameter tools, this is fully satisfactory.

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 ('decision state for every current proposal head') and a clear action ('read-only projection'). It enumerates the statuses and fields included, which makes the tool's function understandable. However, it never names sibling tools such as get_proposal or get_progression, so an agent cannot yet see what makes get_decisions distinct from closely related read-only views.

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

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

No guidance is given about when to call this tool instead of sibling get_* tools. The description states it is read-only and safe, but does not indicate under what circumstances decision state is needed, or list alternatives/exclusions. The usage context is only implied by the noun phrase 'decision state'.

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

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

With no annotations, the description carries the burden, and it does disclose some behavior: it separates targets, distinguishes deterministic from reader-panel families, preserves the target estimand, and 'requests no result direction and grants no eligibility.' However, it never clearly states whether the operation is read-only or whether output is bounded, and phrases like 'grants no eligibility' are ambiguous without context.

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

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

The description is only two sentences, but they are dense and overloaded with specialized terms ('readers', 'target estimand', 'families', 'eligibility'). It is not poorly sized overall, but it is not front-loaded with a plain-language statement of what the tool does, and the final clause adds ambiguity rather than clarity.

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 must explain what the agent will receive; it names categories and distinctions but not the actual shape or fields of the result. The description also relies heavily on unexplained domain vocabulary, making it incomplete for an agent without extensive context about 'disputed originals', 'reader-panel families', and 'target estimand'.

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 is empty and schema coverage is 100%, so there are no parameters the description needs to document. The line 'requests no result direction' reinforces the no-input behavior, exceeding the baseline for a zero-parameter tool.

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

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

The description identifies a resource ('every progressing disputed original') and some output structure ('next-work routes', separating replication-mintable targets from contract-decision targets), but it never uses a plain verb like 'returns' or 'lists' and is buried in domain jargon. It conveys more than the name alone, so it is not a tautology, but an agent would struggle to know exactly what artifact it receives.

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

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

There is no when-to-use or when-not-to-use guidance, and no reference to alternatives among the many sibling tools. 'For every progressing disputed original' implies a scope condition, but it does not explain how to decide between this and tools like get_queue, get_progression, or get_evidence_contract_audit.

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

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

No annotations are provided, so the description must fully disclose behavior. It does not state whether the operation is read-only, what side effects it has, or what constitutes 'typed remediation.' The phrase 'typed remediation' is ambiguous and leaves uncertainty about whether this tool mutates state or just returns a report.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to conveying the tool's narrow purpose, and it does so compactly.

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

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

Even though the tool has no parameters and no output schema, the description omits essential context: what the audit returns, how results are formatted, and what 'typed remediation' implies. An agent cannot fully understand the tool's behavior or expected output from this description alone.

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 of 4 applies. The description does not need to explain parameter meanings because there are none to explain.

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 provides a specific verb ('audit'), a clear scope ('register-wide'), and a precise subject ('explicit accepted token bounds that contradict legacy generic token_delta prerequisite semantics'). This distinguishes it from the other get_* sibling tools, which are general read operations.

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

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

No guidance is given on when to use this tool versus alternatives. The description does not mention any conditions, prerequisites, or exclusions that would help an agent decide if this audit is appropriate for a given situation.

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

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

With no annotations, the description carries the burden of explaining behavior. It meaningfully discloses that the output has six independent axes, that edges identify the same entry across adjacent axes, and that the result does not claim causation or form a score. This is substantive behavioral context beyond the tool name.

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

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

The description is compact and the key semantic constraints are stated directly, with the edge caveat clearly separated. It loses a point because the dense terminology and 'receipts' metaphor require unpacking to be fully useful.

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

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

For a no-parameter getter with no output schema, the description covers the basic shape and the main interpretative caveat. However, it does not explain what the six axes concretely mean, how an agent should use the map, or how this tool differs from closely related siblings, leaving notable 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 has zero parameters, so there is no parameter burden for the description to carry. The baseline for a zero-parameter tool is 4, and the description adds no conflicting or missing 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 names a resource (flagship evidence map) and enumerates its six axes, so it is not a tautology. However, it lacks an explicit verb such as 'retrieves' or 'returns,' and the metaphor 'receipts' plus jargon like 'editorial surface' leaves the actual purpose somewhat opaque.

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

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

No guidance is given about when to use this tool versus siblings such as get_flagships, get_evidence_contract_audit, or get_semantic_map. The only directive-like content is a caveat that edges are identity links, not causation, which is interpretive rather than selection 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 provided, the description carries the burden of behavioral disclosure. It usefully reveals that this is a 'no-score' workbench and describes the returned readiness components, but it does not explicitly state read-only behavior, side effects, authorization needs, or output format. The get_ prefix implies a read operation but is not explicit.

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

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

The description is a single sentence with a colon-separated list and no filler. It front-loads the core idea ('no-score workbench') before enumerating the output categories, making every phrase informative.

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 tool with no output schema, the description names the major output categories (readiness axes, missing work, next scarce action, lifecycle destination) and explicitly says it is not a score. This is enough for an agent to form expectations and invoke the tool safely, though it leaves terms like 'intuitive flagship candidates' undefined.

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 an empty input schema, so the schema covers everything about parameters. With 0 parameters, the baseline of 4 applies because there is no parameter documentation burden for the description to satisfy.

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 that this is a readiness workbench and enumerates specific outputs: six independent readiness axes, missing work, the next scarce action, and the current lifecycle destination. However, it lacks an explicit verb and does not contrast itself with the related sibling tools get_flagships or get_flagship_evidence_map.

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

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

The phrase 'for intuitive flagship candidates' implies when this tool is relevant, and the name implies readiness assessment. There is no explicit when-not-to-use guidance or mention of alternatives, even though several sibling getters are related.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'live lifecycle' and 'joined to' data, implying a read operation, but does not explicitly state that it is read-only, what side effects (if any) occur, or any constraints like authentication. The description focuses on content rather than behavior.

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

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

The description is a single dense sentence packed with jargon ('curated', 'human-facing', 'post-ratification adoption coverage', 'claim guards'). It is not concise and is difficult to parse at a glance. The key resource ('flagship shortlist') is front-loaded, but the accumulation of modifiers reduces clarity.

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?

Without an output schema, the description should explain what the tool returns in a usable way. It lists several data components (lifecycle, evidence, qualification, etc.) but does not specify the structure or format, and 'flagship' itself is undefined. An agent cannot confidently interpret the result or know what to expect.

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

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

The tool has zero parameters and the schema description coverage is 100% (empty schema), so there is nothing for the description to add about parameters. The baseline of 4 applies because no parameter documentation is needed; nothing 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 is a noun phrase ('The curated human-facing flagship shortlist joined to...') rather than a clear statement of what the tool does. It implies retrieval of a flagship shortlist but does not use a verb or explicitly say 'returns' or 'gets'. It is distinguished from siblings by the unique 'flagship' resource, but the meaning of 'flagship' is undefined, making the purpose vague.

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

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

The description provides no guidance on when to use this tool versus the many siblings. There is no mention of context, alternative tools, or conditions that would select this one. An agent is left to infer use from the name alone.

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

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

No annotations are provided, so the description carries full burden. It explicitly discloses what the tool returns: full chain, ordering, field diffs, surface-only flags, and evidence association. This provides comprehensive behavioral expectations 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?

The description is a single, dense sentence that front-loads the main result (supersession chain) and appends specific details in a clear list. Every component adds value without 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 low complexity (one required parameter), full schema coverage, and no output schema, the description is completely adequate. It describes what the tool returns in sufficient detail for an agent to decide to invoke it and understand the output format.

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

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

Schema description coverage is 100% with a single parameter 'slug', described as 'The proposal slug.' The description adds no further parameter details, but with full schema coverage and a straightforward parameter, the description's brevity is acceptable. Score 4 because the description still helps clarify the parameter's role in context of the tool's purpose.

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

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

The description clearly states the verb 'get' and the resource 'a proposal's full supersession chain', specifying ordering (oldest first) and listing the exact information included per hop (field diffs, surface-only status, evidence). This distinguishes it from siblings like get_changelog or get_proposal, which might have overlapping but different purposes.

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

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

The description implies usage when you need the full supersession history with detailed per-hop diffs and evidence tracking. However, it does not explicitly state when not to use this tool or mention alternatives (e.g., get_changelog for a simpler log). Given the context of 18 siblings, some exclusions would be helpful, but the purpose is sufficiently clear to infer appropriate use.

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

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

With no annotations provided, the description effectively communicates the tool's behavior: it is a read operation that returns detailed measurement data. It specifies the hash prefix requirement (>=12 hex chars) and the exact data payload, providing clear behavioral context.

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

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

The description is a single sentence that efficiently lists the key data returned, but it is slightly dense with multiple data points which could be structured for easier parsing.

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

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

Given the single parameter, full schema coverage, and no output schema, the description adequately details the tool's purpose and the nature of its return data. However, it could specify that the output is likely a JSON object or structure, which 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?

Schema description coverage is 100%, so the schema already documents the 'hash' parameter. The description clarifies the prefix requirement ('full or >=12-char prefix') but does not add significant meaning beyond what the schema provides.

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

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

The description includes the specific verb 'get' and the resource 'measurement by manifest-hash prefix', and lists the exact data returned (manifest verbatim, per-member results, replication chain, replicate-POST kit). This clearly distinguishes it from siblings like 'submit_measurement' or 'get_register'.

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

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

The description implies the tool is used to retrieve a specific measurement by a hash prefix, but provides no explicit guidance on when to use it versus alternatives like 'get_history' or 'get_changelog', nor does it specify when not to use it.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It does provide useful details: the clocks are 'separate recomputable' and the 'deprecation sweep fails closed on expiry,' implying fail-closed behavior. However, it does not clarify whether the operation is read-only, whether auth is needed, or what the response contains.

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

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

The description is short and front-loaded with the main subject, but it is dense and jargon-heavy. The closing sentence 'This is not external adoption' is unexplained and likely to confuse an agent rather than clarify scope.

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 getter, the description gives a reasonable inventory of the returned instruments. Yet with no output schema, the agent still lacks guidance on the return shape, and the cryptic negation does not round out the picture.

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 description cannot add parameter-level meaning beyond the empty schema. Baseline 4 is appropriate, and the description correctly focuses on the domain data returned.

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

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

The description names a specific resource ('observatory instruments') and enumerates its contents: corpus attestations, recomputable scanner-schedule and evidence-validity clocks, and the deterministic gate's firing record. This goes beyond a tautology and gives the agent a concrete sense of what the tool returns, though it does not explicitly state the action verb or contrast with 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?

No when-to-use guidance is provided; the description does not state what problem this tool solves or when it should be preferred over siblings like get_adoption_snapshot or get_changelog. The only directional signal is the cryptic 'This is not external adoption,' which is not actionable.

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

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

With no annotations provided, the description carries the full burden for behavioral context. It mentions that the tool returns computed metrics like 'bus-factor concentration RISK' and 'independence structure', and mentions a 'refuses' list that documents what it will not compute. This is helpful but lacks details on data freshness, computation time, or whether results are cached.

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 relatively concise at two sentences, front-loading the main purpose. The second sentence adds important caveats. Some technical jargon ('verb vectors', 'bus-factor concentration RISK') could be simplified, but the length is appropriate for the complexity.

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 complexity of the concept (analyzing contributor participation patterns) and the lack of an output schema, the description provides a reasonable overview of what the tool returns. However, it could elaborate on the structure of the output or what 'scarce verbs' means. The context signals show zero parameters and no output schema, which puts more burden on the description.

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

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

The tool has zero parameters and 100% schema description coverage, so the schema already fully documents the lack of inputs. The description adds no parameter information, which is appropriate since there are none. The baseline of 4 is justified because the description doesn't need to compensate.

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 that the tool analyzes contributor participation patterns including verb vectors, community shape metrics, and identifies staffing gaps. It explicitly states what the tool is NOT (a leaderboard), which helps differentiate it from potential siblings like get_contributor or whoami. However, the purpose could be more precise about the resource being queried.

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 minimal guidance on when to use this tool versus alternatives. The 'Deliberately NOT a leaderboard' statement helps set expectations but doesn't explicitly suggest alternatives. With 18 sibling tools including get_contributor and how_to_participate, more contextual guidance would be beneficial.

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 adds important constraints: batches 'grant no eligibility, set no priority and predict no outcome.' It also scopes the tool to active proposals and clarifies that paths are conditional. It does not explicitly state read-only behavior, but the get prefix and the caveats make that reasonably clear.

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

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

The description is compact, with the core topic front-loaded and a single useful caveat in the second sentence. It is dense and somewhat jargon-heavy, but every clause adds information and nothing 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?

The description covers the tool's subject matter, its scope, the key components, and the non-effects of the result. Given that there are no parameters and no output schema, this is sufficient for an agent to understand what it is retrieving. It could be slightly clearer about the exact return shape, but the description is otherwise complete.

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

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

The input schema has zero parameters, so the baseline is 4. There is no parameter semantics to explain, and the description instead focuses on what the returned progression data means.

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—ordered conditional paths for active proposals—and details its contents: current evidence contract, SDK-first work packet, and capability batches. It clearly separates this from other get_* siblings by describing the unique data structure. It stops short of a 5 because it is phrased as a noun phrase rather than an explicit action verb, leaving the 'get' action to the tool name.

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

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

The description provides no guidance on when to use this tool versus alternatives such as get_progression_throughput or get_queue. It implies it is relevant to active proposals but does not state use cases, prerequisites, or 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 disclosure burden. It does add genuine semantic context — metric components (distinct proposals, seconding thresholds, ratifications), exclusion of replications, and the 1/7/30-day windows — and the final sentence serves as an interpretive guardrail. But it never states that the operation is read-only or what the returned payload looks like, leaving those traits to be inferred from the 'get_' prefix.

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?

At two sentences it is appropriately brief and every phrase carries meaning, but the first sentence is a grammatically fragmented enumeration that is hard to parse on first read. The central claim is not front-loaded as a clear verb-plus-object statement.

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, the description covers the metric's semantics well, which is the main thing an agent needs to interpret results. Yet with no output schema, the return format is never described — the agent cannot tell whether the result is a single throughput figure, a per-window breakdown, or counts versus rates.

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 is empty, so there are no parameters to document; the zero-parameter baseline of 4 applies. The description correctly adds measurement context rather than inventing 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 defines what the tool measures — activity over 1/7/30-day windows, distinct proposals, seconding thresholds, and ratifications — and adds a useful negative ('raw measurement-submission volume is never called proposal progress'). However, there is no explicit verb or statement of what the tool returns; the first sentence is a string of noun fragments ('...activity windows separating... distinct proposals measured...') that forces the agent to infer the operation from the 'get_' prefix.

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

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

No guidance is given for when to choose this tool over any of its 40+ siblings such as get_progression, get_adoption_trends, or list_measurements. The only contrast offered is a semantic disclaimer about what does not count as progress, which clarifies interpretation but does not route the agent to an alternative.

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

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

No annotations are present, so the description carries the full burden. It hints at one boundary ('report-only disclosed-linked-seconder coverage') but never states that this is a read-only operation, what side effects could occur, or how the response behaves. The 'Metric semantics' sentence is too cryptic to count as meaningful behavioral disclosure.

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

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

The text is compact and front-loaded with 'One proposal in full', but the long comma-separated list and the cryptic final sentence make it dense and hard to parse. It is concise in length but not optimally structured for comprehension.

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 single-parameter getter with no output schema, the description enumerates the main return content, which helps. It is still incomplete for an unfamiliar agent because the domain concepts are unexplained and no usage context is given; however, the basic 'get one thing by slug' contract is present.

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

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

Schema description covers the only parameter (slug: 'The proposal slug.') at 100%, so the description does not need to add parameter details. It adds no extra semantics but also does not need to.

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

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

Opens with 'One proposal in full', clearly scoping the operation to a single proposal rather than a list, and enumerates the returned facets (measurements, votes, readiness, supersession, etc.). However, the jargon ('human evidence story', 'disclosed-linked-seconder coverage') is opaque and prevents a 5.

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

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

No explicit guidance on when to call this versus siblings like get_progression or get_measurement; the only hint is 'One proposal in full'. There are no prerequisites, exclusions, or alternative-routing statements.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It fails to state whether the tool is read-only, what side effects occur, authentication needs, or expected behaviors. A bare definition of the data returned is insufficient.

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

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

The description is a single sentence with no wasted words. It is appropriately concise for a parameterless tool, but it could be improved by front-loading the verb and stating the action explicitly 'Get the measurement protocols...'.

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

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

The tool has no output schema and no annotations, so the description must explain what the tool returns. It only defines the concept of protocols without stating that the tool returns a list of them. For a simple retrieval tool, the description is incomplete.

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

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

The tool has zero parameters and schema coverage is 100% trivially. The description adds no parameter information because none is needed. Baseline for 0-param tools is 4, and the description meets that standard without deficiency.

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 defines what measurement protocols are ('public metric definitions a construct is judged against') but does not explicitly state that the tool retrieves or lists them. The verb 'get' is implicit, but the description reads as a noun phrase definition rather than a clear action. It provides some context but lacks specificity about the tool's function, and does not distinguish from siblings like 'get_measurement' or 'get_observatory'.

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

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

The description offers no guidance on when to use this tool versus alternatives, no exclusions, and no prerequisites. It simply defines the concept without any contextual direction.

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

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

With no annotations, the description carries the full burden. It discloses meaningful behavior beyond a trivial 'get queue' reading: route values, section_meta semantics, and constraints on who may file measurements. It does not mention pagination or ordering, but for a read-only feed the provided context is substantial.

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

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

Three dense sentences, each carrying distinct information: what the feed is, what route values exist, and what section_meta explains. 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?

Given this is a zero-parameter tool with no output schema, the description is largely complete: it explains the feed's scope, the status vocabulary, and the meaning of the returned metadata. A note about pagination or response shape would make it fully complete, but it is not a critical gap for invocation.

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

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

The input schema has zero parameters, so the baseline is 4. The description adds value by explaining what the returned feed contains, including route states and section_meta, which is the only semantic content an agent has to work with.

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 ('open-work feed') and a specific purpose: surfacing public proposals by their primary route. It lists all seven route states, which clearly distinguishes this tool from siblings like get_proposal or list_proposals.

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?

Calling it 'the canonical open-work feed' gives clear context for when to use it: to see the current queue of actionable work. It does not explicitly exclude alternatives or name sibling tools, but the canonical framing strongly implies the intended use.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It meaningfully explains that qualification is 'configuration- and expiry-bound' and explicitly states what the tool does not infer: 'model families, training-data exposure, ownership or independence.' This goes beyond a simple inventory claim and helps set expectations.

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

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

The description is compact and front-loaded with the core purpose. It is jargon-heavy, but the two sentences each earn their place: the first states what the tool returns, the second clarifies important limitations.

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

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

For a no-parameter, no-output-schema, no-annotation tool, the description is largely complete: it specifies the subject matter, included data dimensions, and boundaries. It does not detail return format or pagination, but the low complexity and clear scope make this a minor gap.

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

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

The tool has zero parameters, so there is little for the description to add beyond schema coverage. The description still usefully clarifies the scope of the returned data (identifiers, provenance, qualification coverage), which is the relevant semantic context for a parameterless call.

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

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

The description clearly identifies the resource ('exact model-reader, tokenizer and other instrument identifiers') and positions it as a 'derived inventory' of the public evidence corpus, which distinguishes it from sibling get_* tools. It lacks an explicit verb like 'lists' or 'returns,' relying on the noun phrase and tool name, but the intent is unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives, and it does not mention any exclusions or preferred sibling tools. An agent would need to infer usage from the tool name and general context.

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

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

No annotations exist, so the description must carry the full transparency burden. It states the content of the register but does not disclose behavioral traits such as read-only-ness (though 'get' implies it), authorization needs, rate limits, side effects, or response format. Since it is a simple retrieval with no parameters, the lack of buthlavioral detail is less severe, but the description adds no transparency beyond the content. It does not contradict any annotations because none exist.

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

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

The description is a single sentence of moderate length, no waste. However, the structure is a noun phrase with a colon, which is slightly less readable than a verb-first declarative sentence. It is concise but could be front-loaded more clearly. Still, every word serves a purpose.

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

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

The description explains what the register contains but does not describe the output format (e.g., is it a list, an object, a JSON structure?) or provide any context about the 'ratified register' concept. With no output schema, the burden is on the description to inform about return values. It fails to do so. The domain is specialized and the description omits necessary foundational explanation for an AI agent to understand the result.

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

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

The input schema has zero parameters and schema description coverage is 100% trivially. According to instructions, 0 parameters baseline is 4. The description does not need to add parameter meaning since there are none. It correctly omits param reference.

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 defines the resource as 'the ratified register' and specifies its content (language constructs with adoption, plus project protocols with not_applicable status). The action 'get' is implied by the tool name and the noun-phrase description is interpretable as a retrieval operation. However, it lacks an explicit verb like 'retrieve' or 'list', and the jargon may confuse an agent unfamiliar with the domain. Still, it distinguishes from siblings like get_register_pack and get_protocols by defining the scope of the register.

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 does not provide any guidance on when to use this tool versus alternatives. Among siblings (get_register_pack, get_protocols, get_changelog, etc.), there is no explanation of when get_register is appropriate or when to prefer another tool. No context signals about prerequisites, filters, or derived usage are given. This leaves the agent to infer from the name alone.

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

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

With no annotations, the description bears full responsibility. It discloses token-budgeting, version+digest stamping, and exclusion of kind:protocol. However, it does not clarify what 'token-budgeted' means operationally (e.g., truncation, rejection), or mention error behavior or access requirements. Some useful detail but incomplete.

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

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

The description is two sentences and front-loads the key purpose ('The register as a PROMPT'). The first sentence is dense with specialized terminology but still efficient. No wasted words, though clarity could be improved with slightly simpler 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?

With no output schema, the description should explain what the tool returns. It mentions token-budgeted and that it mirrors /register.txt, which provides some expectation but is vague. For a simple fetch tool this is adequate but not complete; an AI agent might need more detail on the format or constraints of the returned prompt.

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 100% coverage, so baseline is 4. The description adds no parameter information because none are needed. It appropriately describes the purpose without redundant param 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 retrieves the register as a PROMPT, specifying that it contains ratified language constructs with exclusions (kind:protocol). The verb 'get' and resource 'register pack' are distinct, and the description differentiates it from siblings like 'get_register' (presumably raw) by adding token-budgeted and stamped details.

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

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

The description implies the tool is for fetching the register into working context for adoption, and mentions it mirrors /register.txt. It does not explicitly compare with alternatives like get_register, but the context 'as a PROMPT' signals when to use it. Lacks explicit when-not-to-use or prerequisites, keeping it slightly above average.

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

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

With no annotations, the description carries the behavioral burden. It clearly discloses the output scope and what is deliberately excluded, which is meaningful context beyond the tool name. It does not state obvious operational details like read-only status or return shape, but for a zero-parameter get tool this is a minor gap.

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

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

The description is compact and every sentence adds relevant scope or exclusion information. The phrasing is dense and somewhat jargony, but it is not padded and the core result is front-loaded.

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

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

With no output schema and no annotations, the description must explain the return value and scope. It does so by specifying the exact set of entries and listing what is not included. It is adequate for an agent to decide whether to call this tool, though it could be stronger by naming relevant sibling alternatives.

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 is empty, so there are no parameters for the description to clarify. Per the baseline for zero-parameter tools, this is appropriate; the description need not add parameter-level semantics.

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

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

The description identifies a specific result: 'exact visible, ratified language entries absent from the latest published public-domain bundle.' This is clear about the resource and scope, though it does not explicitly distinguish itself from sibling tools by name.

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

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

The description implies when to use the tool: when you need the exact visible, ratified entries missing from the bundle. It mentions exclusions ('required bundle-field checks, evidence summaries, optional flagship-explanation status and not-shortlisted status remain separate') but does not name alternative tools or give explicit when-not-to-use 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 provided, the description carries the full burden and does meaningful work: it discloses determinism ("Deterministic lexical neighborhoods"), which tells an agent the output is reproducible and safe to rely on, and it explicitly disclaims semantic authority ("Candidates route review only and never assert semantic equivalence"), preventing the agent from over-trusting the data. These are genuine behavioral disclosures beyond what the tool name implies, though they remain somewhat abstract.

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 zero filler; the core content is front-loaded and the behavioral caveat follows. Every word earns its place, and the length is appropriate to a parameterless fetch tool.

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

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

For a parameterless fetch with no output schema and no annotations, the description is roughly adequate — the tool's core semantics are stated. But the central jargon ("lexical neighborhoods," "supersession edges," "candidates") is left unexplained, and the return shape is never addressed; since there is no output schema, the description is the only place that information could live. Given the low complexity, this is acceptable but leaves real gaps for an agent without domain knowledge.

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 of 4 applies — there is nothing the description could meaningfully add about arguments. Schema coverage is trivially 100% since the schema is an empty object, and the description correctly adds no spurious parameter detail.

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

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

The description states a specific deliverable — the semantic map — and its two concrete contents ("deterministic lexical neighborhoods" and "declared supersession edges"), which is reasonably clear for an agent in the domain. However, it relies entirely on domain jargon ("lexical neighborhoods," "supersession edges") and never differentiates itself from the many get_* siblings like get_register, get_history, or get_changelog, so it earns a 4 rather than a 5.

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

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

No guidance is given on when to use this tool versus alternatives. With 25 siblings including numerous similar get_* fetches (get_register, get_register_pack, get_contribution_terms, get_history), an agent receives no routing help, no exclusions, and no named fallbacks — the description says nothing about selection context at all.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It states that reviews are 'append-only', tallies are 'advisory' and 'surface-bound', and that 'reviews never create proposal relations'. These are meaningful behavioral traits beyond the bare 'get' action. However, it omits details like whether the operation is purely read-only, any authentication requirements, or side effects beyond the relation statement.

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

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

The description is a single, dense sentence that front-loads the core identity ('deduplicated lexical-candidate review queue') and appends behavioral qualifiers. It wastes no words and is appropriately sized for a zero-parameter tool. Slight jargon may hinder readability, but the structure is 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?

With no output schema, the description must clarify what the tool returns. It implies a list of review candidates with tallies, but it does not explicitly state whether the output is the entire queue, the tallies only, or both. The term 'advisory tallies' is left ambiguous. Given the zero-parameter simplicity, the description is not severely incomplete, but it could be more explicit about the response shape and content.

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 there is nothing to explain. According to the rubric, 0 parameters merits a baseline of 4. The description correctly avoids inventing parameter details and does not need to compensate for missing schema coverage.

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

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

The description identifies the tool as a 'deduplicated lexical-candidate review queue' which conveys a specific resource and implies a retrieval operation consistent with the 'get_' prefix. It distinguishes from siblings like get_queue or review_semantic_pair by the 'semantic reviews' focus. However, it lacks an explicit verb like 'Get' or 'List', relying on the name for the action.

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

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

The description provides no guidance on when to use this tool versus alternatives such as get_queue, get_history, or review_semantic_pair. It does not mention conditions, context, or exclusions, leaving the agent to infer usage solely from the tool name.

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

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

No annotations are provided, so the description must fully disclose behavior. It fails to state that this is a read-only, informational tool with no side effects. The mention of 'write tools' could mislead an agent into thinking this tool performs writes or requires write context.

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

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

The description is minimal (single sentence) but packs domain-specific terms without explanation, reducing clarity for an agent. It is moderately concise but sacrifices understandability.

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

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

Despite a trivial empty schema and no output schema, the description is incomplete for a documentation tool: it does not specify output format (text, JSON?), nor explain its cryptic terms. An agent cannot fully anticipate what this tool returns or how to process it.

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

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

With zero parameters and 100% schema coverage, the description does not need to add parameter meaning. The absence of param info is acceptable, so the 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 is vague and jargon-heavy ('Colony token-exchange recipe', 'lifecycle', 'gates', 'harnesses'), lacking an explicit verb or outcome. It does not clearly state that the tool returns instructional documentation, leaving its purpose ambiguous despite the suggestive name.

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

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

There is no guidance on when to use this tool versus the many sibling tools (e.g., propose, vote, submit_measurement). The description does not clarify that this is a reference/documentation tool rather than an action tool, nor does it provide exclusions or alternatives.

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

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

With no annotations, the description carries the full burden, and it does thoroughly: newest-first ordering, snapshotted keyset pagination with an id ceiling, authenticated cursor binding, concurrency guarantees, and rejection of replay under changed filters. It also explains row identity (attempt_id) and content identity (url/manifest_hash), which is non-obvious behavior an agent must know. This is strong behavioral disclosure.

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

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

The description is about 100 words, front-loaded with the core purpose, and each sentence addresses a distinct concern: scope, row identity, pagination semantics, concurrency, and filters. It is dense but not padded, and no sentence is wasted.

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

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

For a 6-parameter optional-filter list endpoint with no output schema and no annotations, the description covers ordering, pagination safety, identity, and filter semantics. The schema supplies parameter constraints such as limit range and cursor formatting. It does not describe the response envelope, but an agent has enough detail to call the tool and iterate correctly.

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

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

Schema description coverage is 100%, so the baseline is met. The description adds meaning beyond the schema by explaining that attempt_id is exact row identity and that url/manifest_hash may be shared by historical same-manifest rows. It also groups the filters in one sentence, reinforcing their roles. It does not duplicate limit details, which remain adequately covered by the schema.

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

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

The opening phrase 'The public evidence corpus, newest first — every visible measurement' clearly identifies the resource and ordering. The phrase 'so it can be swept without walking each proposal' distinguishes this from an alternative workflow, though it does not explicitly name sibling tools like get_measurement. Scope is unambiguous.

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

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

The description indicates the tool is for sweeping all visible measurements without per-proposal iteration, which is a clear when-to-use signal. It also gives explicit pagination instructions ('Follow next_cursor verbatim') and cautions against replay under changed filters. It does not contrast with single-item retrieval via get_measurement, so some routing inference is left to the 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?

With no annotations, the description carries the full disclosure burden, and it does well: it states stability ('stable page'), field precision ('exact seconds_count'), and important semantics ('report-only disclosed_linked_seconders coverage', 'never a gate'). It also spells out the pagination contract. It does not cover auth, rate limits, or full response shape, but the disclosed behaviors 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?

Two tight sentences with no filler. The core purpose is front-loaded, and the field semantics plus pagination contract are compressed into the second sentence without losing clarity.

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 five-parameter list endpoint with no output schema and no annotations, the description is incomplete: it omits the meanings of since, limit, and stage, and gives no guidance on selecting this tool among many siblings. It covers pagination and row-level field semantics, but an agent would still be uncertain about the full request and response contract.

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

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

Schema coverage is only 40%, covering q and cursor, while limit, since, and stage lack descriptions. The description adds meaningful meaning only for cursor via the pagination directive; it says nothing about how q filters, what since means, how limit behaves, or how stage selects pipeline phases. It does not compensate for the low schema coverage.

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

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

The description clearly identifies the resource ('a stable page of proposals') and its scope ('at every stage of the pipeline'). It does not explicitly differentiate from siblings like get_proposal or list_measurements, but it conveys a distinct paginated, cross-stage listing purpose.

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

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

The only usage guidance is the pagination instruction to follow next_cursor until has_more is false. There is no mention of when to prefer this tool over sibling list/detail tools, nor any exclusions such as 'use get_proposal for a single proposal' or 'use list_measurements for measurements.'

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses the AUTH requirement, the freezing of a canonical sha256 commitment, and the obligation to close the attempt. It doesn't detail failure modes or side effects of not closing, but the disclosed traits are significant and non-contradictory.

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 and conveys all necessary information: auth, timing, the action of freezing a commitment, and the closure condition. Every phrase contributes meaning with no redundancy or filler.

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

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

Given the tool's complexity (6 parameters, nested objects, no output schema, no annotations), the description provides essential workflow context about preregistration, commitment, and closure. The schema covers parameter specifics. It doesn't explain return values, but no output schema exists, and the lifecycle is sufficiently clear for an agent to use it correctly.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters. The description adds context about the manifest's role (the exact object to later file) and the commitment mechanism, but it doesn't provide additional detail on parameter formats or relationships beyond the schema. This aligns with the baseline of 3 for high schema coverage.

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

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

The description clearly states the tool's purpose: 'preregister one measurement attempt BEFORE reader spend.' It specifies the action (preregister), the resource (a measurement attempt), and the timing, distinguishing it from siblings like submit_measurement and abort_attempt. The mention of a canonical sha256 commitment further clarifies the unique function.

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 indicates when to use this tool ('BEFORE reader spend') and describes the required lifecycle: 'A completed measurement or an evidenced abort must close the attempt.' While it doesn't explicitly name alternative tools, the workflow implies that submit_measurement or abort_attempt are the subsequent steps, making the usage context clear.

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 is unusually rich: it discloses gating at generated_at, routing of incomplete evidence to cards, no change to ballot eligibility, handling of legacy filings, separation of blocked suggestions with reasons and next slots, settlement-bearing reruns, optional operator disclosure that only subtracts, and deterministic anti-herding rotation. This gives an agent a detailed behavioral 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 a dense block of semicolon-laden domain-specific clauses without a clear topic sentence. The cryptic opener "AUTH:" and the compound sentences hurt scanability. Although most clauses carry information, the structure is not appropriately sized or front-loaded.

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

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

For a complex tool with no output schema and no annotations, the description covers numerous edge cases: eligibility, incomplete evidence, blocked suggestions, legacy filings, settlement semantics, and deterministic rotation. It is largely complete, but it still lacks a simple summary of the response shape and explicit auth/rate-limit expectations beyond the 403/429 mention, so it is not a 5.

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

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

The input schema already describes the optional proposal parameter in detail ("Optional immutable public_id. Return every eligible task for this proposal, without discovery caps; empty is not a hidden-record disclosure"), and schema coverage is 100%. The description adds little about this parameter, so the baseline score of 3 is appropriate.

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

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

The description indicates the tool offers personalised open-work suggestions ("AUTH: personalised open work", "suggestions passed ... gates"), but it never states a direct verb+resource sentence such as "Returns personalised suggestions for open work". The jargon-heavy prose makes the core purpose inferable rather than explicit, and it doesn't clearly distinguish the tool from siblings like get_queue or get_proposals.

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

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

There is no explicit when-to-use guidance or comparison with alternative tools. Some situational behavior is described (blocked_suggestions for 403/429 candidates, settlement-bearing reruns), but the description never tells an agent when to choose this over get_queue, get_proposals, get_agent_runbook, or any sibling.

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 safety burden. It explicitly discloses the most important behavioral traits: it is non-writing, performs only validation, allocates no id, opens no obligation, and consumes no attempt budget. It does not describe the return value or failure behavior, but the key side-effect profile is clearly stated.

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

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

The description is two sentences with every clause earning its place. It front-loads the crucial safety classification ('AUTH, NON-WRITING'), then states the operation, constraints, and relationship to mint without redundant 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 complex six-parameter tool with nested objects and no output schema, the description is somewhat terse. It gives a strong behavioral summary but does not explain what a successful or failed preflight returns, nor does it elaborate on domain-specific concepts like 'reader spend' or 'attempt pin'. It is probably sufficient for tool selection, but less complete for invocation.

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

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

Schema description coverage is 100%, and the input schema already provides meaningful descriptions for all parameters. The tool description itself adds little parameter-level meaning; 'exact attempt pin' and 'reader spend' provide domain context but do not clarify individual fields beyond the schema.

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

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

The description clearly identifies the action ('validate the exact attempt pin'), the resource ('attempt pin before reader spend'), and the non-writing nature. It also distinguishes itself from the related mint operation by stating that it allocates no id, opens no obligation, and consumes no attempt budget.

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

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

The phrase 'before reader spend' provides an explicit temporal/context cue for when this tool should be used, and the closing note that 'Mint repeats validation under lock' implies that a real allocation should happen through mint_attempt instead. It does not explicitly name the alternative tool or state when not to use it, but the guidance is clear enough.

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

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

With no annotations provided, the description carries the full disclosure burden. It discloses that this is a real write that atomically records contribution terms, that contribution_terms is an optional exact pin, and that evidence_contract is advisory and does not affect ballot eligibility. It does not cover permissions or error/rollback behavior, but the key side effects and semantic nuances are explained.

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 dense and long, but nearly every clause adds needed field semantics for a complex nested payload. It is front-loaded with the core purpose; a bulleted list or schema-like layout would improve readability, but there is no filler or tautology.

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 a complex single nested parameter, no annotations, and no output schema, the description covers the input payload thoroughly enough for an agent to construct and submit a correct proposal. It omits response/return behavior and explicit permission requirements, but the invocation path and field semantics are substantially 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 only says 'The full proposal payload,' so the description is the main source of parameter meaning. It enumerates the required/optional fields, explains the problem field's compatibility fallback, specifies contribution_terms pinning, and describes evidence_contract structure and layered semantics for legacy strings vs bounded objects.

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

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

The description opens with the specific action 'file a construct proposal,' naming both the verb and the resource. Referencing the POST /api/v1/proposals endpoint and enumerating the proposal fields disambiguates it from sibling tools like vote, second, or replace_vote.

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 clearly implies its use when filing a construct proposal and gives detailed field semantics, but it never states explicit conditions for use or names alternatives/asides. There is no 'use X instead' guidance, so the agent must infer when this tool is the right choice.

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

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

With no annotations provided, the description carries the full behavioral burden. It does disclose a meaningful side effect: the former value and required reason remain in public history. However, it omits other behavioral details such as reversibility, error cases, or what happens after the replacement is recorded, so transparency is partial.

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

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

The description is two sentences with no filler, and the main operation is front-loaded. The 'AUTH:' prefix is somewhat cryptic and slightly harms clarity, but overall the length and structure are efficient.

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

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

For a simple three-parameter mutation tool with no output schema and no annotations, the description covers the operation, a key constraint, and an important side effect. Still, parameter semantics and post-conditions are left mostly to inference, making it adequate but not complete.

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

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

Schema description coverage is 0%, so the description must compensate for the three parameters. It mentions 'value' and 'reason' but adds little beyond the schema's own field names and required flag. It does not clarify what 'slug' refers to, what 1 and -1 mean, or what constitutes a valid reason, leaving the agent to infer the semantics.

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

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

The description clearly states that the tool replaces the caller's active vote while the ballot remains open, which is a specific verb and resource. It is implicitly distinct from siblings like vote and withdraw_vote, though it does not name them explicitly. The 'AUTH:' prefix adds slight ambiguity but does not obscure the core purpose.

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

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

The description gives explicit conditions for use: only for an active vote and only while the ballot is open. This is enough for an agent to understand when replacement is appropriate, though it does not explicitly contrast with alternatives like vote or withdraw_vote.

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 covers key behavior: non-destructive ('without deleting it'), immediate effect, mandatory public reason, and the side effect that retracting an original retires dependent voices. It also discloses an optional correction-link relationship. It does not address reversibility, permissions, or response details, but the main behavioral surface is exposed.

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 pack the effect, a precondition, a side effect, and an optional-parameter relationship with no redundancy. The cryptic 'AUTH:' prefix adds little value and the replacement logic is dense, but the description remains compact and front-loaded.

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

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

For a mutating tool with no annotations and no output schema, the description covers the action, preconditions, side effects, and optional chaining well enough for an agent to call it correctly. It could state whether retraction is reversible or what the response/result is, but those gaps are minor relative to what is disclosed.

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?

At 0% schema coverage, the description must supply meaning, and it does: reason is public and required, the retracted row is 'this exact attempt_id,' and replacement_attempt_id is the 'later same-role corrected row' whose manifest.correction_of references it. It never names the parameters by schema key, but the semantics are inferable from the sentence structure.

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 defines the operation as stopping a completed measurement from affecting verdicts without deleting it, which is a specific verb+resource+effect. It also adds scope — 'completed measurement' and 'your' — that separates it from abort_attempt and other mutation siblings.

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

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

It clearly communicates the triggering context: use when a completed measurement must no longer affect verdicts, and it notes the public-reason requirement and original/dependent-voice consequence. It does not name alternatives or explicitly state when not to use it, but the context is sufficient for an agent to avoid choosing get_* tools or abort_attempt.

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 behavioral burden. It does disclose a key non-mutating guarantee: 'Even unanimous reviews never mutate duplicate_of or supersession edges.' It also labels the review as 'advisory,' implying it is non-authoritative. However, it does not describe other behaviors such as idempotency effects, failure modes, or persistence details, leaving gaps.

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 and no redundant filler. The conditional requirement and behavioral guarantee are front-loaded before the second sentence. The only minor issue is the leading 'AUTH:' prefix, which is unexplained and could confuse agents, but overall it is structurally efficient.

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

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

Given the tool has 6 parameters (5 required) and one conditional, no annotations, and no output schema, the description is insufficiently complete. It does not explain the core parameters, the meaning of the decision values, what 'surface-bound' and 'advisory' imply for system state, or how idempotency is handled. An agent would struggle to construct a valid call without further documentation.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It only clarifies that 'expected_predecessor also requires predecessor_slug,' which is a conditional dependency. It does not explain left_slug, right_slug, reason, decision enum values (beyond the name being self-explanatory), or idempotency_key. The description provides minimal additional meaning for most parameters, failing to compensate for the schema's lack of descriptions.

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

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

The description clearly states a specific action: 'append a surface-bound advisory review of one current lexical candidate pair.' This includes a concrete resource (lexical candidate pair) and distinguishes it from read tools like get_semantic_reviews. It is not a tautology and immediately conveys the write nature of the tool.

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

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

The description implies when to use the tool (to add a review) but does not explicitly contrast it with alternatives such as get_semantic_reviews or other proposal tools. The mention of the conditional predecessor_slug requirement provides some usage context, but there is no explicit 'use this instead of X' guidance, leaving some inference to the 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?

With no annotations provided, the description carries the full burden. It clearly discloses that the optional explanation fields are stored verbatim and immutable, that omitting them still leaves the second valid, and that each act counts as one toward the 3-seconder threshold. It does not cover withdrawal, idempotency, or failure modes, but the core side effects are well described.

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 dense but efficient, packing the core purpose, semantic distinction, counting rule, and optional-field behavior into one sentence. The long em-dash clauses slightly reduce scannability, 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?

For a simple action without an output schema, the description explains the action's meaning, the optional inputs, and the counting rule. It leaves gaps around the expected slug value, whether the same user can second multiple times, and what a successful response looks like, but the essential call contract is conveyed.

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

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

The schema already documents two of three parameters; the description adds meaning by clarifying that worth_measuring_because and weakest_part are optional, stored verbatim/immutable, and can be omitted without invalidating the second. However, the required 'slug' parameter is not clarified—an agent must infer it refers to the proposal identifier from context.

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

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

The description states a specific verb ('second') and resource ('a proposal') and immediately clarifies the intended meaning by distinguishing 'worth measuring' from 'worth adopting'. This semantic contrast differentiates it from adoption/voting tools, so an agent can understand exactly what action this tool performs.

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 concrete usage context: advancing a proposal needs 3 distinct seconders and each act weighs 1. The 'not worth adopting' phrase gives an exclusion that steers away from adoption, though it does not explicitly name the alternative sibling tool such as 'vote'.

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. Discloses that the tool requires authentication ('AUTH') and that it submits a measurement. Mentions the measurement shape (metric, value, manifest) and optional attempt_id. However, does not describe side effects, idempotency, validation rules, or error scenarios. Adequate but not rich.

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

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

Two sentences: first states the core action and key components, second gives conditional advice. No filler, every word contributes. Very 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?

Tool has 2 params (one nested object), no output schema, no annotations. Description explains what to submit and when, but omits return value, error handling, and whether submission is idempotent. Relies on external references ('/panel.py', get_protocols) which may not be accessible to the agent. Barely sufficient for a mutation tool.

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

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

Schema coverage is 50% (slug has no description, measurement has a vague reference). Description adds meaning: explains measurement object contains 'metric, value, manifest — the re-runnable SPEC' and clarifies the required attempt_id when preregistered. This compensates for the schema's lack of detail, especially for the nested object.

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?

Verb 'submit' clearly indicates creating a measurement. Resource is 'measurement for a seconded proposal' with specific components (metric, value, manifest). Distinguishes from sibling 'get_measurement' (read) and 'mint_attempt' (preregistration) by stating the submission context and referencing related 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?

States when to use: after a proposal is seconded, and if preregistered with mint_attempt include attempt_id. References get_protocols for understanding the SPEC. No explicit when-not-to-use statement, but context from siblings implies this is for submission after seconding, not for reading or other actions.

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

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

With no annotations, the description carries the behavioral burden and does provide some useful disclosures: the operation is atomic and leaves both rows public. However, it does not explain the full side effects, such as whether the original attempt loses the settlement voice, whether the action can be reversed, or what the AUTH marker actually requires.

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

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

The description is compact and front-loads the auth and atomicity cues before the core action. The phrasing is dense but every portion contributes; a fifth point is withheld because the AUTH marker and domain jargon are cryptic without supporting context.

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

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

This is a state-changing tool with no annotations, no output schema, and no per-parameter documentation, so the one-sentence description is insufficient for confident invocation. Missing context includes what a deterministic settlement voice is, what happens to the original row's voice, and the operational prerequisites or failure modes.

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

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

Schema descriptions are absent, but the description partially clarifies the parameters: successor_attempt_id is the already-filed exact-input correction and attempt_id is the prior row, with both rows remaining public. The optional reason parameter still receives no semantic explanation beyond its self-evident name and length constraint.

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 action: transfer the caller's deterministic settlement voice to an already-filed exact-input correction atomically. It also notes a useful state outcome: both rows remain public. It does not, however, differentiate itself from sibling tools like replace_vote or withdraw_vote, so it stops short of a 5.

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

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

No guidance is given about when to use this tool versus alternatives such as replace_vote, vote, or abort_attempt, nor are exclusions stated. The only contextual clue is the prerequisite that the correction already be filed, which is too weak for an agent to make routing decisions.

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

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

With no annotations, the description must disclose behavioral traits. It mentions the vote is public and has weight 1, and the 'AUTH:' prefix hints at authentication, but it does not describe side effects, reversibility, or any constraints (e.g., whether a vote can be changed). Given this is a mutation tool, important behavioral details are missing.

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

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

The description is a single concise sentence followed by a parameter clarification. It is front-loaded with the core action and avoids redundancy. The inclusion of 'AUTH:' is slightly unconventional but not wasteful. Overall, it is efficient without being too terse.

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 two parameters, no output schema, and no annotations, the description should fully explain usage. It covers purpose and value semantics but leaves slug undefined, does not discuss preconditions beyond 'deterministic gate is clear,' and omits behavioral outcomes (e.g., confirmation, errors). For a mutation tool, this is incomplete.

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

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

Schema coverage is 0%, so the description must compensate. It explains 'value' as 1 (for) or -1 (against) clearly, adding meaning beyond the enum. However, 'slug' is not explicitly defined—only contextually implied as the proposal identifier. The description partially covers parameters but leaves one ambiguous.

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

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

The description clearly states the action ('cast a public ratification ballot') and the resource ('a measured proposal whose deterministic gate is clear'). It distinguishes from siblings like propose or second by specifying the ratification context. The parameter meaning for value is also explicit, making the tool's purpose unmistakable.

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

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

The description implies when to vote (on a measured proposal with a clear deterministic gate) but does not explicitly contrast with alternatives like replace_vote or withdraw_vote. It gives context that the vote is public and weighted equally, but lacks explicit 'use this when...' or 'instead of...' guidance, leaving some ambiguity.

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

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

The description discloses that the tool returns identity info, write permission status, and operator linkage, and notes that the opaque ID is never exposed. However, it does not explicitly state the tool is read-only or what happens on error. Given no annotations, it carries a moderate burden and somewhat succeeds but with confusing language.

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

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

The description is a single convoluted sentence with unnecessary jargon and a confusing dash-separated clause. It is not front-loaded; the key point about returning identity is buried. Could be much shorter and clearer.

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

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

With no output schema, the description should fully explain the return structure. It mentions identity, write gate, and operator-linkage but does not specify format, fields, or data types. The cryptic 'confirmation needs no disclosure' adds confusion without clarity.

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 input schema covers everything trivially. The description adds context about authentication (Bearer token) and what the tool checks, going beyond the schema. Baseline for no 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 starts with 'AUTH:' and mentions returning identity, write gate status, and operator-linkage status, which gives a general sense of the tool's purpose. However, the phrasing is cryptic with jargon like 'agent-first: confirmation needs no disclosure', obscuring the core function. It distinguishes from siblings implicitly by focusing on current user info.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any prerequisites, such as needing a valid token, nor does it contrast with similar tools in the 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?

With no annotations, the description fully carries the behavioral burden and does it well: it discloses irreversibility, public persistence as a tombstone, and the headcount effect. This is substantial, decision-relevant information beyond the schema.

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

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

A single compact sentence, with the most important constraint (irreversible/AUTH) front-loaded and no filler. Each clause adds 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?

For a two-parameter tool with no output schema, the description is near-complete: it states the operation, key effects, and reason visibility. It omits what slug references and any error/return behavior, so a bit of ambiguity remains.

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

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

The schema has no descriptions (0% coverage), and the description adds only the tombstone behavior for reason; it never explains slug or the semantics/format of reason beyond implying public retention. The burden falls on the description, and it does not meet it.

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

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

The description states an explicit action ('withdraw'), a specific resource ('your second'), and key distinguishing traits (irreversible, tombstone, headcount). This separates it from siblings like second, replace_vote, or withdraw_vote without needing the schema.

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

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

It conveys when the tool is relevant—withdrawing a second—but it never names conditions, exclusions, or alternatives. An agent must infer that second is the counterpart and withdraw_vote is a different operation, so guidance is implied rather than explicit.

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

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

With no annotations, the description carries the full burden and does so well: it discloses irreversibility, the persistence of a public tombstone, and that the withdrawn vote no longer counts. These are non-obvious behavioral side effects an agent needs to know 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?

Two short sentences with no wasted words, and the key action and irreversibility are front-loaded. The cryptic 'AUTH:' prefix is unexplained and slightly ambiguous, but the rest is tightly structured.

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

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

The action and side effects are clear, but the description is incomplete for a two-parameter tool with no output schema and no annotations. Missing parameter semantics and any indication of what the response will be leave notable gaps for an agent deciding how to call it.

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

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

Schema description coverage is 0% and the description does not mention either parameter. It does not explain what 'slug' identifies or why 'reason' is required, leaving the agent to guess the meaning of both required fields.

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 ('withdraw'), a clear resource ('your active vote'), and a scope condition ('while the ballot remains open'). It clearly differentiates from siblings like vote and replace_vote by emphasizing irreversibility and the public tombstone effect.

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 clear context on when the action applies: only while the ballot remains open and only for an active vote. It does not explicitly name alternatives such as replace_vote for changing a vote, so it stops short of full when/when-not guidance.

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