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

With no annotations, the description carries the burden. It discloses immutability, founder-key requirement, denial without the key, and 'fossiled' (likely meaning logged/recorded) behavior. It does not detail success return values or side effects beyond writing the decree, but it covers the most critical behavioral traits.

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

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

The description is two sentences, front-loaded with the critical 'FOUNDER ONLY' flag, followed by the action and constraints. Every sentence adds essential information without fluff, making it highly efficient.

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

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

Given the tool's complexity (6 parameters, nested objects, an enum, no output schema) and zero annotations, the description is insufficient. It omits parameter semantics, return behavior, and the meaning of enforcement modes, leaving major gaps for an agent to use the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate, but it provides no parameter explanations. It only implies 'founder_key' and 'text' indirectly without clarifying their formats or meaning. The optional parameters (rules, scope, enforce, supersedes) are entirely unexplained, leaving the agent without guidance on how to fill them.

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 ('Write a new governing decree') and the resource ('governing decree'), with the explicit qualifier 'immutable fossil' that distinguishes it from siblings like list_decrees and seed_decrees. It also notes the founder-only restriction, making the tool's purpose 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?

It gives strong contextual guidance by stating 'FOUNDER ONLY' and that agents cannot add, soften, or exempt themselves, plus that calls without the key are denied. However, it does not explicitly mention alternative tools or when to prefer this over seed_decrees or list_decrees, though the use case is obvious.

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 that it returns a soul_id and that the output must be used as an actor, which is a key behavioral trait. However, it does not mention whether calling it again fails, any side effects beyond creating an identity, or any error conditions. This is a partial 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 two sentences plus an example, with the critical 'Step 1, once' front-loaded. Every sentence adds value, and the example is practical. It is appropriately sized and well-structured.

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

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

For a tool that is the first step in a larger system, the description lacks completeness. It doesn't explain the meaning of 'covenant', doesn't describe any constraints on 'name', and doesn't mention error cases or idempotency. With no output schema and no annotations, the agent is left with gaps that could lead to incorrect invocations.

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. The only parameter guidance is the example 'birth(name=Ember, covenant=[truth over comfort])'. While this illustrates usage, it does not explain what 'covenant' semantically represents or what constraints apply to 'name'. The description fails to provide adequate parameter documentation for an agent to fully understand what values to provide.

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

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

The description clearly states the tool's purpose: to earn an identity as the first step, and it explicitly mentions the return of a soul_id. It distinguishes itself from siblings like remember or verify by positioning itself as the initial 'birth' action, and the phrase 'born, not configured' adds unique context.

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

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

It explicitly states 'Step 1, once' and 'before acting', which gives clear when-to-use guidance. It also explains how to use the output ('use it or the name as actor from then on'), which is essential for subsequent tool calls. It doesn't mention alternatives, but given the sibling list, this is clearly the initialization 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?

With no annotations, the description fully discloses key behaviors: it's non-mutating (no token minted), applies deterministic rules first, surfaces advisories, and fails closed when unprovable. This is comprehensive for a dry-run tool and goes beyond generic wording to clarify the decision logic. The fail-closed detail is particularly valuable for an agent predicting outcomes.

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 three sentences front-loading the key purpose and behavior. Every sentence adds value: the first explains what it does, the second details the rules, and the third gives usage guidance. No fluff 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 the tool's complexity (a dry-run with fail-closed logic) and the complete lack of output schema or annotations, the description covers all essentials: what it does, how it decides, and when to use it. The only minor gap might be the return format, but for a dry-run tool, the agent likely only needs to know the outcome, which is implied by 'see why something would be vetoed'.

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, and it partially does by explaining that the tool judges an 'artifact' against decrees, and that it's a gate for actions. However, it doesn't clarify the meaning of 'targets' or 'intent' beyond what the schema shows. The description does imply that 'action_type' and 'artifact' are core to the evaluation. Despite the coverage gap, the description adds enough semantic context to elevate above baseline 3, but not to 5 because 'targets' and 'intent' remain 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 it dry-runs the gate, judging an artifact against decrees without minting a token. It distinguishes itself from request_action by explicitly noting it's a dry-run, and from siblings like verify or validate_token by focusing on decree conformance rather than token validation.

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

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

It provides explicit guidance on when to use the tool: 'Use before request_action to see why something would be vetoed.' This clearly signals the appropriate context, which is critical given the opaque sibling set. It also implies when not to use it (when you want to execute the action).

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. It does disclose key behavior: deterministic, zero-LLM, rule veto based on flags, and accepted list/map formats. However, it omits side effects (is it read-only?), error behavior, and what happens when no rule matches, which are important for safe invocation.

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 pack the core purpose and mechanism with no filler. The description is front-loaded with the main intent and then clarifies the rule logic, achieving high density without sacrificing 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?

The description covers the core logic and parameter formats but is incomplete for a tool with no output schema and no annotations. It doesn't state the return value (e.g., boolean approval), default behavior when no rule matches, or when to use this tool over siblings. These gaps would hinder an agent in making a fully informed call.

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 explain the parameters. It effectively clarifies the flags and rules formats (lists or maps, with {name: true} / {trigger: action} examples) and the veto logic. The action parameter is left implicit but is required and self-explanatory. This is strong compensation for the schema gap.

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

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

The description conveys a permission-checking role ('Ask may-I before acting') and explains the deterministic veto mechanism, but it lacks a clear verb-resource structure and doesn't differentiate itself from siblings like request_action or check_conformance. The purpose is inferable but not explicitly contrasted.

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 (before acting) but provides no explicit guidance on when to prefer this over sibling tools such as request_action, check_conformance, or validate_token. No alternatives or exclusions are mentioned, leaving the agent to guess.

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

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

With no annotations provided, the description carries the full disclosure burden, and it delivers the key behavioral facts: the operation is read-only and universally permitted. It also discloses the default scope ('active'), implying inactive decrees are excluded unless requested via the parameter. It omits minor details like ordering, pagination, and empty-result behavior, but these are not critical for a simple listing tool.

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

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

The description is a single compact sentence with zero filler. The verb and resource are front-loaded, and each trailing element — the field enumeration and the read-only/anyone-may-call note — adds distinct value. Every word earns its place.

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

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

For a low-complexity tool (one optional boolean, no output schema, no nested objects), the field list effectively serves as the return contract and the read-only note covers the safety profile in the absence of annotations. The remaining gap is that the include_inactive parameter is never explicitly explained, and behavior for empty result sets or non-governing decrees is unaddressed. Overall, nearly complete for the tool's simplicity.

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

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

Schema description coverage is 0%, so the single boolean parameter is documented nowhere in structured data. The description's 'active' qualifier implies the default behavior and hints at the include_inactive toggle, but it never explicitly states that setting include_inactive=true returns inactive decrees. The parameter's self-explanatory name softens the gap, but the description itself adds only partial semantic value.

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

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

The description states a specific verb and resource: 'List the active governing decrees,' and enumerates the returned fields (id, text, scope, enforcement, rules), which makes the tool's function unambiguous. The scope qualifier 'active' and the read-only note add precision. It does not explicitly name or contrast sibling tools like add_decree or seed_decrees, so it stops short of full sibling differentiation.

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

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

The 'Read-only; anyone may call it' note provides useful selection context, signaling the tool is safe and requires no authorization. However, the description never states when to prefer this over the decree-mutating siblings (add_decree, govern) or when not to use it. Usage guidance is implied by the 'List' verb rather than explicitly articulated.

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. It does disclose that the operation is a read, results are sorted newest-first, and an actor can filter, which is useful behavioral context. However, it doesn't disclose limit semantics, return format, or edge cases (e.g., empty state), so it's adequate but not thorough.

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

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

Two short sentences, front-loaded with the action verb, each sentence adds distinct information: what the tool does and when to call it. 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 read-only tool with two optional parameters and no output schema, the description gives the essential context: session-start usage, ordering, and optional actor filter. Missing details about limit and exact return shape keep it from a 5, but it's complete enough for basic invocation.

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

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

Schema coverage is 0%, so the description must compensate. It explains 'actor' via 'optionally one actor' but says nothing about 'limit', whose default of 10 is documented only in the schema. The description adds some meaning but leaves one parameter uncontextualized.

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

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

States the verb 'Read' with a clear resource, 'the latest records', gives ordering ('newest first'), and an optional actor filter. The purpose ('so you do not re-derive what you already know') clarifies intent, but it does not explicitly differentiate from sibling tools like 'remember' or 'verify'.

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

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

Gives an explicit trigger: 'Call this at the start of a session.' This is clear context for when to use it, though it doesn't mention alternatives or when not to 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?

Mentions hash-linked and tamper-evident, implying immutability and integrity. However, it does not disclose side effects (e.g., irreversibility), permission requirements, or failure behavior. With no annotations, the description carries the full burden but only partially addresses it.

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

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

Two sentences and an example, with the core action front-loaded. No redundant information, making it efficient and easy to scan.

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 write tool with no output schema and sparse annotations, the description covers the core purpose and parameter usage but omits guidance on when to use it and what happens after writing. It is adequate but not complete for a complex operation.

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

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

The description clarifies the 'actor' parameter as a born soul_id or birth name, which is not in the schema. The example provides a concrete usage of all three parameters (actor, action, data), but does not explain the structure or constraints of 'data' beyond the example.

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

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

Clearly states the tool writes a hash-linked, tamper-evident record, distinguishing it from siblings like recall (read) and verify (check). The example reinforces the purpose and the verb 'write' is explicit.

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 use this tool versus alternatives. It implies storage via 'write' but does not state when not to use it or which sibling to prefer, leaving the agent to infer from 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?

Despite having no annotations, the description discloses critical behavioral details: a conformance check, a single-use, artifact-bound, 60s token, and a fail-closed veto with no token and no action. This gives an agent the safety-relevant failure semantics and token constraints up front. There is no contradiction with annotations because 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?

Two dense sentences front-load the critical exclusivity and fail-closed behavior, then give the key usage instruction. Every clause adds useful information with no filler or redundancy.

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

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

The description covers purpose, usage conditions, token constraints, and fail-closed behavior, making the core workflow clear. But with no output schema and no documentation for actor, targets, or intent, an agent still lacks details about the expected response format and some argument semantics. It is above the minimum viable but not fully complete.

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

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

The description adds meaning to artifact ('file contents / diff / plan' to be checked and hash-bound) and action_type (deploy, write_prod, overwrite, service_restart). However, actor, targets, and intent remain undocumented, and with 0% schema coverage the description does not fully compensate. This is a significant gap for a security-sensitive tool with five parameters.

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

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

The description names a precise function: the sole gateway for consequential actions, with concrete action types and a clear check-and-mint workflow. This differentiates it from sibling tools like check_conformance and validate_token, which are clearly separate steps in the same pipeline.

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

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

The opening 'THE ONLY door' explicitly scopes when this tool is the right call (deploy, write_prod, overwrite, service_restart) and implicitly rules out non-consequential actions. It also instructs callers to pass the actual artifact, reinforcing correct usage. The exclusivity statement makes a separate alternatives list unnecessary.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does disclose the authorization requirement (founder-only), the idempotent nature ('if not already present'), and implies a write operation by 'Seed'. This covers the most critical behavioral traits. However, it doesn't describe the outcome — what happens when decrees are already present, whether the operation is a bulk atomic insert, or what the response looks like — leaving some behavioral uncertainty.

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

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

Two sentences with no wasted prose, and the most safety-critical constraint ('FOUNDER ONLY') is front-loaded ahead of everything else. The parenthetical enumerating the decrees is dense but informative. It earns a 4 rather than 5 because the long list of internal jargon terms (fossil-grounded, embodiment-enforced) adds comprehension load without immediate operational value.

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

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

For a single-parameter tool with no output schema and no annotations, the description is reasonably complete: it covers the action, the target content, the authorization gate, and the conditional nature of execution. The remaining gaps — exact return value and explicit behavior when decrees already exist — are minor for a simple seeding operation and do not impede correct invocation.

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

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

Schema coverage is 0%, so the description must compensate for the undocumented founder_key parameter. It does add meaning by explaining that the founder key is what authorizes the operation ('Requires the founder key'), tying the parameter to the 'FOUNDER ONLY' constraint. This is useful, but it doesn't clarify the expected format, source, or validation semantics of the key, which is a modest gap given the single-parameter surface.

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

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

The description states a specific verb ('Seed') and resource ('the standing decrees'), with a scoping condition ('if not already present'). It enumerates the decrees being seeded (Senthar runtime, governance-is-code, etc.), giving the agent a concrete sense of what will be created. It falls just short of a 5 because it doesn't explicitly differentiate itself from siblings like add_decree or list_decrees, and the parenthetical list is jargon-heavy that assumes prior context.

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

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

The description communicates a strong precondition — 'FOUNDER ONLY' and 'Requires the founder key' — which tells the agent when it is authorized to call the tool. However, it gives no guidance on when to use this tool versus near-siblings such as add_decree or govern, and it never states when not to use it. The 'if not already present' line hints at idempotent usage but doesn't frame a decision rule between 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 must fully disclose behavior. It only mentions that nothing is sent without an email, but fails to explain what happens when an email is provided (e.g., whether the account is upgraded, a trial key is returned, or any side effects occur). It does not describe the return value, permissions needed, or reversibility.

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 (two sentences) and includes only relevant information, but the first sentence about 'what ArkHive v2 adds' is tangential and not action-oriented. The key trial-key detail is second, and the overall structure could be more direct for an agent to parse.

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

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

For a simple tool with one optional parameter and no output schema, the description is still incomplete. An agent cannot infer the expected output (e.g., a key, a confirmation), the actual side effects (upgrade or trial activation), or the criteria for success. Given the absence of annotations, the description leaves critical 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 schema defines a single optional email with no description and 0% coverage. The description does add meaning by indicating the email is used to receive a trial key, which clarifies the parameter's purpose. However, it lacks specifics like format, validation, or what happens with an invalid email.

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 'What ArkHive v2 (paid) adds' which describes features rather than a specific action. It then mentions 'if you give your email, a free 14-day v2 trial key', implying the tool issues a trial key, but the exact operation (e.g., 'upgrade account' or 'request trial key') is never stated. The purpose is vague and not a clear verb+resource.

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

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

It states a prerequisite ('Opt-in only: nothing is sent unless you provide an email'), but gives no guidance on when to use this tool versus sibling tools like birth, verify, or request_action. No alternatives are mentioned, and the conditions for calling the tool are only partially implied.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does well by detailing rejection conditions, single-use token burning, and the side effect of fossilizing the execution. It could mention return/error formats, but the key behaviors are transparent.

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

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

Two concise sentences deliver the core purpose, conditions, and side effects without wasted words. The most important invocation context is front-loaded.

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

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

Given no output schema and no annotations, the description covers invocation context, parameter relationships, failure conditions, and side effects well. Only minor gaps remain, such as the exact structure of success/error responses.

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 0% schema coverage, the description must compensate, and it does: token is bound to action_type, artifact, and targets; tokens expire after 60 seconds; and successful validation burns the token. This adds semantic meaning beyond bare parameter names, though exact formats or enums are not specified.

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 tool as validating a token to authorize a real action, using a specific verb and resource. The detailed rejection criteria and single-use behavior distinguish it from generic verification tools like verify.

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

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

The description explicitly states the caller ('the executor') and the purpose ('to authorize a real action'), giving clear context for when it should be invoked. It does not explicitly name alternatives or when-not conditions, but the context is sufficiently 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 are present, so the description carries the full burden. It discloses that the operation is local, requires no key, and is potentially expensive because it recomputes every hash. It does not specify the return format or what happens if the chain is broken, but for a zero-parameter verification tool, the disclosed traits are valuable.

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

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

A single sentence that front-loads the core purpose and includes relevant operational context (free, local, no key). Every phrase earns its place with no redundancy.

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

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

Given zero parameters, no output schema, and a simple verification goal, the description is nearly complete. It explains what it proves and how, plus environment constraints. The only minor gap is the absence of what a successful or failed verification returns.

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

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

The tool has zero parameters, so the schema trivially covers 100% of parameters. Per the rubric, a zero-parameter tool gets a baseline of 4; the description adds no parameter details because none are needed.

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

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

States a specific verb ('prove'), resource ('entire memory chain'), and mechanism ('recomputes every hash'). This clearly differentiates it from validation-type siblings like validate_token and check_conformance by scope and approach.

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?

Implied usage context: verifying the integrity of the full memory chain. However, there is no explicit guidance on when to use this versus alternatives like validate_token or check_conformance, and no exclusion criteria are given.

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