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

The description adds meaningful behavioral context beyond annotations: it states the default policy denies external and destructive risks, and that the server never executes the action itself. Since annotations are all false and provide no positive safety guarantees, these statements help agents understand the tool's limited, non-executing role.

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. The core behavior is front-loaded, and the second sentence adds a critical policy and execution boundary. Every sentence earns its place.

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

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

The description covers purpose, default policy, and non-execution, which is strong given the output schema exists. However, it lacks usage guidance relative to sibling tools and does not clarify what the authorization result represents or how it should be consumed before proceeding with an action.

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 input schema already documents all parameters. The description mentions risk policy and session budget, which loosely contextualize risk and estimated_cost_usd, but it does not add parameter-level detail 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 uses a specific verb and resource: 'Evaluate an intended action against server-owned risk policy and the session budget.' It also clarifies a crucial boundary: 'this server never executes the action itself,' which distinguishes it from execution-oriented sibling tools. The title reinforces the authorization 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 implies this tool should be used before an action is taken, since it evaluates an 'intended action' against policy and budget. However, it does not explicitly state when to use it versus alternatives like record_outcome or check_claim, and it provides no exclusionary guidance.

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

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

Annotations are all false and do not establish a read-only safety profile, yet the description only says 'Determine whether' and does not disclose whether the tool also binds/writes claims or modifies session state. The title suggests a binding side effect, but the description does not clarify it, leaving an important behavioral 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 a single focused sentence with no filler. It front-loads the operation and packs the key qualifiers—claim classes, freshness, success, typed evidence, and verified ledger—into a compact 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?

Although an output schema and full parameter documentation exist, the description omits when to choose this tool, what side effects may occur, and what prerequisites or authorization are needed. For a tool that may not be read-only, this is a substantial completeness 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?

Schema description coverage is 100%, so each parameter is already documented in the schema. The description adds conceptual context by mapping 'fresh successful typed evidence' to the evidence-age and evidence-type parameters, but it does not need to repeat the schema's parameter details.

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

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

The description clearly identifies a specific action, 'Determine whether', and a distinct resource: completion, working, integrity, or deployment claims checked against fresh evidence in the verified session ledger. It does not explicitly contrast siblings, and the title's 'Bind' wording slightly conflicts with the description's 'Determine', but the core purpose 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?

No guidance is given on when to use this tool versus siblings like verify_release or record_outcome. Conditions, prerequisites, and exclusions are absent; usage is only implied by the tool name and description.

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

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

Annotations are all false or unhelpful, so the description carries the full burden, but it only mentions abstract checks and never explains what loading does to current state, whether it overwrites the active session, or what the 'checks pass' failure mode looks like. The title says 'Restore,' suggesting mutation, but the description never clarifies the behavioral impact.

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 filler, and the core action 'Load a checkpoint' is front-loaded. The trailing list of validation checks is compact, though somewhat jargon-heavy.

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

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

Despite having an output schema and fully described parameters, the description leaves the operation's semantics vague: what does 'load' mean for the current session, and what does the caller need to know about preconditions or side effects? The undefined check list is not actionable guidance, so the description is inadequate for a state-affecting restore 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 100%, and both parameters have useful descriptions, so the baseline is 3. The description's mention of 'state hash, expiry, ledger integrity, and lineage' hints at what the checkpoint_id encodes but does not add concrete meaning beyond the schema.

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

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

The description names a clear verb and resource: 'Load a checkpoint' with the title 'Restore a Durable Checkpoint', making the tool's core purpose evident. It does not explicitly differentiate itself from siblings like retrieve_context or checkpoint_save, but the name and title largely carry that distinction.

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

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

The description provides a clear precondition: load only after 'session, scope, state hash, expiry, ledger integrity, and lineage checks pass.' This tells an agent when it is appropriate to invoke the tool. It does not name alternatives or exclusions, which keeps it just below the top of the scale.

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

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

Annotations already flag this as a mutable, non-idempotent operation, and the description adds non-obvious behavior: credential-shaped values are redacted before persistence and the state is tied to session scope and ledger lineage. This is useful context beyond readOnlyHint/idempotentHint and does not contradict annotations.

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

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

The description is a single dense sentence with no filler. It front-loads the verb and scope, though 'bounded... bound to' is slightly clunky.

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

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

With a full input schema, an output schema, and annotations, the description provides the essential behavioral keywords (redact, persist, session scope, ledger lineage). It is nevertheless terse on usage conditions and leaves the meaning of 'bounded' and 'current ledger lineage' implicit, which is a meaningful gap for a stateful 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 100%, so parameters are already documented. The description contributes only the notion of 'bounded' state and 'session scope', largely echoing the schema's own state/session descriptions; retention_hours and label semantics remain entirely schema-dependent.

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 clear action ('Redact and persist') and a resource ('bounded state object'), adding scope ('session scope', 'current ledger lineage') that helps distinguish save from checkpoint_load. It does not explicitly name a sibling or contrast with other tools, so it stops short of full 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?

No guidance is provided for when to use checkpoint_save versus siblings such as checkpoint_load, context_put, or record_outcome. The description implies persistence and scoping but states no conditions, exclusions, or alternative routing.

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

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

Annotations only state that the tool is not read-only, not idempotent, and not destructive. The description adds useful behavioral context: context is redacted, provenance-labeled, and remains historical until independently reverified, which clarifies the write semantics and trust implications beyond the schema and annotations.

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

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

Two sentences with no filler. The first sentence front-loads the core action and key qualities; the second adds an important stateful caveat. Every clause earns its place.

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

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

The description, combined with full schema coverage and an output schema, gives an agent enough to invoke the tool correctly. The main gap is the lack of usage differentiation from siblings, but the core behavioral and parameter context is solid.

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 all parameters are already documented in the schema. The description adds a high-level semantic frame but does not provide additional parameter-level detail beyond what the schema already states about redaction and provenance.

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 ('Add') and resource ('context to the current session'), and adds meaningful qualifiers ('redacted, provenance-labeled') that distinguish it from generic storage tools. It clearly reads as the write-side counterpart to retrieve_context, and the title reinforces a scoped-context 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 no explicit guidance about when to use this tool versus siblings such as record_outcome, checkpoint_save, or retrieve_context. It states what it does, but not when it should be preferred or avoided, leaving the agent to infer usage from the purpose 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 annotations providing no positive behavioral hints, the description carries the disclosure burden and is quite explicit: it consumes an authorization, reconciles reserved cost, and appends a tamper-evident outcome. This signals mutation, consumption of a limited resource, and append-only integrity, though it stops short of describing failure modes or validation 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 sentence with no filler and front-loaded action verbs. Every phrase contributes a distinct behavioral element: consuming authorization, reconciling cost, and appending evidence.

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 schema is rich and an output schema is reported, so the description does not need to explain return values. However, it lacks explicit lifecycle guidance such as requiring a prior livingstack.authorize_action call or a valid session, and it does not address when to choose this tool over related siblings.

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 every parameter. The description adds useful context by tying 'reserved cost' to actual_cost_usd and 'typed evidence references' to evidence_refs/evidence_types, but it does not add meaning beyond what the schema already conveys.

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 specific domain verbs ('consume', 'reconcile', 'append') and resources ('prior authorization', 'reserved cost', 'outcome'), making it clear this tool records the result of an authorized action. It is easily distinguishable from siblings like authorize_action or session_status.

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 after an authorized action has been attempted, but it never explicitly states when to call it or when to prefer a sibling tool. It does not mention alternatives such as verify_release or check_claim, leaving the routing decision to inference.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds useful behavioral context by revealing that retrieval is deterministic and lexical, and by promising provenance and receipt hashes in the response. This goes beyond the annotations without contradicting them.

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

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

The description is a single, dense sentence that front-loads the action and scope, then adds the retrieval method and return contents. Every phrase earns its place, with no redundant or filler language.

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

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

Given the rich annotations, fully covered parameters, and presence of an output schema, the description provides everything needed to invoke the tool correctly. It explains what is searched, how it is searched, and what is returned, leaving no important gaps for this relatively simple retrieval 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 description coverage is 100%, so the schema already documents session_id, query, and limit adequately. The description adds little parameter-level detail beyond the schema, but it does reinforce the 'current session context' relationship for session_id. Baseline 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Search only the current session context'. It further specifies the retrieval method ('deterministic lexical retrieval') and the return contents ('provenance plus receipt hashes'), making it easy to distinguish from sibling tools like context_put.

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 'Search only the current session context' clearly defines when this tool applies, and 'deterministic lexical retrieval' signals it is the right choice for exact lexical lookups within a session. It does not explicitly name alternatives or exclusions, but the scoping is strong enough for an agent to select it correctly.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the mutation is not purely read-only and not destructive. The description adds meaningful context by mentioning 'tamper-evident evidence history', which tells the agent the operation preserves audit integrity and is not a full deletion. This goes beyond the annotations and helps clarify expected 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 one concise, complete sentence that front-loads the primary action and adds a valuable qualifier. It contains no redundant phrases and is appropriately sized for a tool with two parameters.

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 100% schema coverage, an output schema, and the supportive annotations, the description provides sufficient context for an agent to invoke the tool correctly. It does not spell out the exact response format, but the output schema is present, so that is not required. It could have added a note about idempotency, but idempotentHint=false already communicates that.

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

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

Schema description coverage is 100%, so the schema already documents both parameters: session_id and reason. The description adds no new parameter-level detail beyond what the schema provides, and the tool description stays at a high level. A baseline of 3 is appropriate because the schema carries the parameter documentation burden.

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 ('Mark... closed') and resource ('session') with a distinctive qualifier ('preserving its tamper-evident evidence history'). This clearly differentiates session_close from sibling operations like session_status, session_start, and checkpoint_save, so an agent can understand it without needing further 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 implies the tool is used when a session should be closed while keeping its evidence history intact, but it does not explicitly state when to use it versus alternatives such as checkpoint_save or record_outcome. There is a clear contextual signal, yet no explicit 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.

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

With all annotations false, the description carries the behavioral disclosure burden and does add substantial context: it reveals the session is isolated, the scope is immutable, and the budget is a hard between-action ceiling. This goes beyond the generic 'create session' phrasing and gives the agent meaningful expectations about side effects and restrictions.

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, dense sentence with no filler. Every element earns its place: the action, the object, the isolation property, and the key constraints. The most important information is front-loaded.

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

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

For a creation tool with 100% parameter schema coverage and an output schema available, the description covers the essential behavioral constraints and is sufficient for an agent to invoke it correctly. It does not discuss lifecycle details like whether multiple sessions can coexist or what happens on repeat calls, but those are largely covered by the output schema and the idempotentHint=false annotation.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds nuance by labeling the scope 'immutable' and the budget a 'hard between-action ceiling', which is more specific than the schema's 'Maximum cumulative metered cost'. These extra semantics clarify behavioral limits not captured in the parameter 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 uses a specific verb ('Create') and a clear resource ('isolated capability session') with defining attributes: immutable scope, goal, retention period, and hard budget ceiling. It clearly stands apart from the sibling session-management tools, which read status, put context, or close sessions.

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?

Usage is implied rather than explicit: an agent can infer that this tool is for starting a new session, but the description does not state when to use it versus alternatives, nor any prerequisites or exclusions. There is no mention of calling this before other session actions or of constraints like 'only one session at a time'.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior, and the description aligns by saying 'Read'. It adds value by naming the concrete session aspects inspected (scope hash, lifecycle status, budget, pending authorization count, ledger integrity) and introduces no contradictions.

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

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

A single front-loaded sentence states the action, the resource, and the data items of interest without filler or repetition of the schema.

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 fully documented, an output schema present, and annotations covering read-only/idempotent safety, the description is complete for correct invocation. No essential behavior or input detail is missing.

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

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

Schema coverage is 100% and the only parameter is already described as an opaque session identifier. The description adds no parameter-level detail, but there is nothing missing for the agent to supply a valid session_id.

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

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

The description opens with a precise verb, 'Read', and enumerates the exact resource: one session's scope hash, lifecycle status, budget, pending authorization count, and ledger integrity. This distinguishes it from session lifecycle tools like session_start/session_close and by scoping to a single session rather than a general stack status.

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 one session' implies the tool is appropriate when a caller needs a single session's state, but it does not explicitly contrast this with livingstack.status or explain when to choose another sibling. Usage is inferred rather than stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral detail about what the tool reports on—boundaries, risk policy, and capability classes—and its non-session scope, going beyond the annotations.

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

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

Two compact sentences carry all necessary information. The main scoping statement is front-loaded, followed immediately by the key negative distinction, 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?

For a parameterless, read-only tool with a rich output schema and strong annotations, the description is complete. It specifies what the tool inspects, the categories of information returned, and what it explicitly does not do. Nothing essential 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 schema coverage is 100%, so there is nothing for the description to add about parameter meaning. With 0 params, the baseline is 4, and the description appropriately focuses on output semantics instead.

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 ('Describe') tied to a clear resource ('standalone Living Stack MCP server') and enumerates the exact aspects covered: enforced boundaries, configured risk policy, and available capability classes. The explicit negative statement 'This does not inspect a customer session' sets it apart from session-oriented 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?

The description implies a clear usage context: use it for server-level introspection, not for session inspection. It provides an explicit exclusion ('does not inspect a customer session') but does not name the alternative sibling tool, such as livingstack.session_status.

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

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

Annotations already communicate read-only, idempotent, non-destructive behavior. The description adds valuable context beyond them by disclosing that the export is signed with the local Ed25519 identity and that raw context, goals, targets, summaries, and checkpoint state are excluded. This makes the exact behavioral scope 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 and front-loaded, with the main action and signing behavior in the first sentence and the exclusion details in the second. Every sentence earns its place, and no unnecessary filler is present.

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 simple one-parameter schema, an output schema, and annotations covering safety, the description is largely complete: it explains what is produced, how it is signed, and what is excluded. The only notable gap is the lack of guidance for choosing this tool over the trace_report sibling.

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 the only parameter (session_id) described as an opaque Living Stack session identifier. The description adds no additional parameter-level detail, so the schema carries the full burden; this is the baseline expected for full 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 a specific operation: converting the verified lifecycle ledger into metadata-only OTLP/JSON trace data and signing it with the workspace Ed25519 identity. It is unambiguous about the resource and output, though it does not differentiate from the sibling tool livingstack.trace_report.

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 about when to use this tool versus alternatives such as livingstack.trace_report. The phrase 'verified lifecycle ledger' hints at a prerequisite or intended context, but no explicit conditions, exclusions, or alternative-selection rules are stated.

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

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

Annotations already communicate readOnly, idempotent, and non-destructive behavior, so the description's job is to add context. It does so by disclosing that raw private payloads are excluded and that results are aggregate data, which is meaningful behavioral information beyond the annotations.

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

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

The description is a single front-loaded sentence that states the core action, the data scope, and the redaction constraint without filler. Every clause contributes useful 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 single-parameter read-only tool with an output schema, the description provides enough framing: verification, aggregate results, and privacy protection. The phrase 'verify the event chain' is a little underspecified operationally, but the output schema and annotations cover most remaining details.

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 is only one parameter and the schema provides a complete description: 'Opaque Living Stack session identifier.' The tool description adds no extra information about how session_id is interpreted or validated, but with 100% schema coverage, that is not a significant 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 uses specific verbs and resources: 'verify the event chain' and 'return aggregate event, outcome, budget, and lifecycle data.' The redacted aggregation focus helps distinguish it from siblings like trace_export, though it does not explicitly name alternatives.

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?

Usage context is implied: this tool is for verification and aggregate reporting without raw private payloads. However, there is no explicit guidance on when to prefer it over sibling tools such as trace_export or session_status, so the agent must infer conditions.

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

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

The description adds useful behavior beyond the annotations: hashing is 'fresh', the manifest is JSON, and out-of-root paths are deliberately not resolved. This complements the readOnlyHint, idempotentHint, and destructiveHint annotations without contradicting them.

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

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

Two terse sentences front-load the core operation and then add a relevant boundary caveat. There is no repetition, filler, or buried detail.

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 one-parameter, read-only, idempotent tool with an output schema, the description covers the manifest type, root restriction, and unresolved-path behavior. Return values are already handled by the output schema, so no critical information appears 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 only parameter, manifest_path, is fully documented in the schema as 'Absolute path to a manifest inside LIVING_STACK_ALLOWED_ROOTS'. The description mostly restates the root constraint and does not add meaningful new syntax or format details, so the schema carries the semantic weight.

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 title and description name a specific operation: 'Freshly hash each declared file from a JSON manifest' to verify release bytes. The resource is clear (manifest files under an allowed root), and no sibling tool overlaps with release verification, so it is easily distinguishable.

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 operational boundary: files must be under a 'host-configured allowed root', and paths outside it 'remain unresolved'. It does not name sibling alternatives or state an explicit when-not-to-use rule, but the context is sufficient for a read-only verification tool.

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