UNITARES

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

No annotations are provided, so the description carries the full burden. It adds genuine context: the tool is implemented by get_governance_metrics(), the read is non-mutating (in schema description), and each EISV field's interpretation is spelled out (e.g., S is 'drift from the agent's own normal,' V is 'EMA-smoothed E-I imbalance'). But it does not disclose session/ownership prerequisites, whether reads trigger recomputation, or error/staleness 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 purpose is front-loaded in the first clause, followed by a compact implementation note and dense but justified field definitions that every call outcome depends on. The only mildly questionable element is 'Primary workflow name,' which is slightly awkward phrasing but not wasteful.

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 EISV field definitions meaningfully compensate for the absent output schema, and parameter semantics are fully covered by the schema. Still missing are the overall response shape, what lite=false concretely adds beyond 'full diagnostic data,' and when continuity_token/client_session_id actually become necessary, which an agent needs for robust 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 each parameter (lite, include_state, continuity_token, client_session_id) already has rich, behavior-oriented descriptions, including the warning that include_state 'can be large' and that continuity_token is 'not a cross-process resume credential.' The description adds nothing about parameters, so the baseline 3 applies.

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

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

States a specific verb and resource: 'reading current EISV state,' and substantiates it by defining all four EISV fields (E, I, S, V) with ranges and meanings. However, it does not explicitly differentiate from the sibling health_check, which an agent could plausibly confuse with checking working state.

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 'Primary workflow name for reading current EISV state' implies this is the main entry point for reading governance state, and the schema note 'without updating state' adds a mild read-vs-write signal. But no alternatives are named and no when-to-use/when-not-to-use conditions or exclusions are given, leaving routing largely to inference.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It discloses that routing and explicit local degradation are reported, that the tool returns advisory rather than governed judgment, and that it never creates a review verdict. This is meaningful behavioral context, though it stops short of describing side-effect guarantees or failure behavior in more detail.

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, stating the core identity first. Each of the five sentences earns its place: core purpose, key parameter choices, output nature, diagnostics guidance, and exclusion of review verdicts. 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?

Given nine parameters, four enums, and no output schema, the description plus the fully-documented input schema give an agent enough to invoke the tool correctly. The main gap is that the exact shape of the returned 'advisory evidence' is not described, but response_mode='full' guidance partially compensates by pointing to route diagnostics.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds value beyond the schema by framing which parameters matter ('Choose purpose, standard or thorough effort, and whether external processing is allowed') and by giving a concrete response_mode selection rule. It does not repeat every parameter definition, which is appropriate given the schema already documents 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 identifies this as the 'Primary advisory model-help surface' and states that it 'returns advisory evidence, not governed judgment.' It explicitly distinguishes itself from request_review by stating 'consult never creates a review verdict; use request_review for that,' so an agent can differentiate it from sibling tools without opening schemas.

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 direct usage guidance: choose purpose, effort level, and external-processing allowance, and use response_mode='full' for route diagnostics. It also names the specific alternative for review verdicts ('use request_review for that'), making the when-to-use vs when-not-to-use boundary 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'get full details' and does not explicitly state whether this is a read-only metadata lookup, what output shape to expect, or how lite/full modes affect 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 very short, front-loaded, and free of bloat. The second sentence mostly reinforces the first, so it is concise but not maximally information-dense.

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 8 parameters, no annotations, and no output schema, yet the description only provides a one-line summary. It does not describe return values, the meaning of 'full details', or the lite/full behavior, leaving too much for the agent to infer.

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 each parameter already has a meaningful description, so the baseline is 3. The tool description itself adds no parameter-level semantics beyond implying 'full details' by default.

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 ('Get full details') and the resource ('a specific tool'), so an agent can understand what the tool does. It is not a tautology, but it does not explicitly differentiate itself from sibling tools beyond the obvious semantic scope.

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?

'Deep dive into any tool' implies the tool should be used when an agent needs detailed information about a tool. However, there are no explicit when-to-use or when-not-to-use instructions, and no alternatives are named.

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 transparency burden. It discloses the return payload explicitly and 'health check' + 'returns' strongly implies a non-destructive read. It stops short of stating side-effect freedom, auth needs, or failure/error behavior, but for a health-check tool the core behavior is adequately conveyed.

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 first states the function and payload, the second states the use case. Information is front-loaded and every sentence earns its place.

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

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

Given no output schema exists, the description usefully enumerates the return categories. Parameters are fully covered by the schema, and the top-level schema description ('Perform deep diagnostic check of the governance system') adds domain context. Minor gaps: no explicit read-only declaration and no error/edge-case behavior, but these are low-stakes for a health check.

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

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

Schema description coverage is 100%, so the schema alone fully documents all 4 parameters, including nuanced constraints (e.g., continuity_token is 'not a cross-process resume credential'). The tool description adds no parameter-level information, so the baseline of 3 applies.

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

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

The description uses a specific verb ('returns') tied to a clear resource ('system status, version, component health, and continuity mode'), which precisely defines what the tool does. It is naturally distinguishable from all sibling tools, none of which are health/monitoring related.

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?

'Useful for monitoring and operational visibility' gives clear context for when to invoke the tool. It does not, however, explicitly name alternatives or exclusions (e.g., no differentiation from the closest sibling check_working_state, nor guidance on 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?

No annotations are provided, so the description carries the full disclosure burden. It only hints at a read/mutate split ('inspect' vs 're-bind') and omits important behaviors such as implicit identity auto-creation on first call, the distinction between session-bound and cross-process credentials, and the fact that 'name' is cosmetic only.

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 efficient sentence with no filler, and it front-loads the two core operations. It is not a 5 because for an 8-parameter identity-management tool, this terseness borders on under-specification rather than deliberate conciseness.

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

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

The rich schema compensates for much of the missing context, explaining parameter roles and ownership constraints. However, with no output schema and no annotations, the minimal prose leaves gaps about return values, the auto-create side effect, and how inspect/rebind interact, making this minimally viable rather than 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 100% and the parameter descriptions are unusually detailed (e.g., name sets display_name only; continuity_token is same-live-process only). The main description adds no parameter-level meaning, so the baseline 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 states a specific verb and resource ('inspect' or 're-bind' + 'identity'), and the schema reinforces this with 'Who am I? Auto-creates identity if first call.' It is clear about what the tool operates on, but it does not explicitly differentiate itself from sibling tools such as start_session or self_recovery, 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?

There is no guidance about when to inspect versus rebind, when to use this tool instead of a sibling like start_session, or what prerequisites apply. The description simply names the operations; an agent must infer usage from the parameter semantics.

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, and it discloses nothing: no side effects, no destructiveness (cleanup, supersede, update), no mutation warnings, no auth/provenance requirements, no fallback behaviors. The description is a name list, not a behavior statement. The schema hints at some behaviors (e.g., 'fail honestly when unsupported', LLM fallback), but the description itself adds zero 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 single sentence is compact, but this is under-specification, not conciseness—a 12-action, 51-parameter monolith is summarized as one comma-separated verb list. There is no grouping of read vs. write vs. administrative actions, no hierarchy, and no explanation of the operations. The structure front-loads nothing usable; it reads like a table of contents rather than a tool definition.

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

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

For a tool with 12 actions, 51 parameters, no output schema, and no annotations, this description is severely incomplete. It does not define the semantics of any action, explain which parameters apply to which actions at a conceptual level, describe return behavior, or list side effects. The schema's per-parameter notes partially compensate, but the tool-level knowledge needed to select and invoke actions correctly is essentially 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?

Schema description coverage is 100%, so the baseline is 3 even without parameter info in the description. The schema already documents each parameter including action-scoping notes like '(for action=search)' and constraints such as 'values above 100 are capped'. The description adds no parameter-level meaning, but at this coverage level it 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?

The description identifies the resource ('knowledge graph') and lists 12 operation verbs (store, search, get, list, update, details, note, cleanup, synthesize, stats, supersede, audit), which is specific enough to avoid being a tautology. However, it is a flat catalog of operation names with zero explanation of what each operation means, and the 'Unified' framing does little to distinguish this monolith from siblings like store_finding, update_finding, or search_shared_memory. An agent still cannot tell what 'supersede', 'note', or 'cleanup' actually accomplish.

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 or when-not-to-use guidance exists anywhere in the description. Given sibling tools named store_finding, update_finding, search_shared_memory, and consult, there is heavy potential overlap with the store/update/search actions of this tool, and the description provides zero routing criteria. An agent is forced to open both schemas and infer the boundary, which is exactly what the description should preempt.

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 adds genuinely useful detail about the EISV measurement semantics (ranges, mixed-provenance estimates, EMA smoothing, interpretation of Valence), which explains what the tool computes. However, it does not disclose the write/side-effect behavior of recording (persistence, state mutation, reversibility) or any response-shape expectations beyond EISV fields.

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

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

The description is compact, front-loaded with the purpose, and every part earns its place: the EISV field definitions are dense but precisely defined with ranges and provenance notes. The acronym density (EISV, EMA, E-I) is a minor readability cost, and the 'implemented by outcome_event()' clause is slightly implementation-flavored, but overall it is tight and information-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 complex 14-parameter tool with no output schema and no annotations, the description explains the core EISV return semantics well but omits the practical call flow: what effect recording has, what a 'lite' snapshot contains, and how prediction_id/verification_source fit into the workflow. The schema covers parameter fallbacks, so the main gap is the absence of an end-to-end behavioral overview and explicit side-effect disclosure.

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 and the schema already documents all 14 parameters in detail. The description adds value mainly by explaining the EISV ontology, which clarifies the meaning of include_semantics and response_mode, but it does not add meaning to most individual input parameters. This is acceptable given the schema's thoroughness.

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: 'recording outcomes', and labels the tool as the 'Primary workflow name' for that purpose, which signals it is the canonical entry point. It does not explicitly contrast itself with siblings like store_finding or update_finding, so it lacks the explicit sibling differentiation required for 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 phrase 'Primary workflow name for recording outcomes' gives an implied usage context: this is the go-to tool when an outcome needs to be recorded. However, there is no explicit when-to-use vs. when-not-to-use guidance, no named alternatives, and no prerequisites or exclusion criteria, so the guidance stops at implication.

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 usefully reveals the default thesis-reuse behavior and that the outcome is a reviewer answer or verdict without duplicating the brief. However, the schema hints at multiple action modes (request/reassign, get/list, thesis/synthesis) that the description never mentions, and nothing is said about side effects, ownership requirements, or success/failure conditions.

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

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

Three dense sentences, front-loaded with the core purpose and ending with the actionable parameter switch. Every sentence earns its place and there is no filler. The opening phrase 'Primary workflow name' is somewhat redundant with the tool name, which keeps this from a 5.

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

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

This tool has 9 optional parameters, no annotations, and no output schema, yet the description covers only the request action flow. It ignores the other actions implied by the parameter descriptions (reassign, get, list, thesis, synthesis), and does not explain side effects, what a successful request returns, or how identity/continuity tokens factor in. A 9-parameter tool with zero annotation support needs a more complete orientation than this.

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

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

Schema coverage is 100%, so the baseline is 3. The description does add real meaning to use_brief_as_thesis and issue_description by explaining how the brief becomes the thesis and how to opt out. Most other parameters (reason, agent_id, continuity_token, proposed_conditions) receive no added context beyond their schema descriptions, and the multi-action meanings hinted at in the schema are not reconciled.

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

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

The description states a specific purpose: it is the primary entry point for a structured review workflow, implemented via dialectic(action='request'). It clarifies what the tool produces — a reviewer answer or a verdict — and distinguishes it from siblings like record_result and health_check. It could be sharper (the phrase 'primary workflow name' is slightly abstract), but the core verb+resource is clear.

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 choose this tool over alternatives such as consult, start_session, or record_result, and no exclusions are stated. The only usage hint is the parameter-level instruction to pass use_brief_as_thesis=false for the explicit two-call flow, which is behavioral parameter guidance rather than tool-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?

No annotations are provided, so the description bears the full burden of behavioral disclosure. It does not state whether the operation is read-only, whether it can perform other actions like store or update, what happens on failure, or any side effects. The implementation note is the only behavioral hint, and it may mislead the agent into thinking the tool only searches.

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 free of fluff, but it is under-specified: it uses an odd nominal phrase 'Primary workflow name' and does not front-load concrete behavioral information. It is concise in length but not in effective communication.

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

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

For a tool with 36 parameters, no annotations, and no output schema, a one-sentence description is completely inadequate. It fails to mention the broader action surface (store, update, audit, synthesize, details, etc.), return value format, or any operational context. The agent has to infer almost everything from the parameter schema.

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

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

Schema description coverage is 100%, with detailed descriptions for all 36 parameters, so the baseline is 3. The tool description adds no parameter-level meaning beyond noting action='search', which is not a parameter in this schema. It neither supplements nor conflicts with 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 says this is a 'Primary workflow name for memory search' and that it is implemented by knowledge(action='search'). This conveys the general purpose (searching shared memory) but is vague about what the tool actually does and how it differs from sibling tools. It borders on restating the tool name and relies on the implementation detail to add meaning.

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 is given about when to use this tool versus alternatives. The phrase 'Primary workflow name' weakly implies it is the standard entry point for memory search, and the mention of knowledge(action='search') hints at the underlying implementation, but there are no conditions, exclusions, or comparisons to sibling tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'self-recovery' without explaining side effects, state changes, ownership requirements, or what happens during check/quick/review. Important behavioral context appears only inside parameter descriptions (e.g., continuity_token ownership proof), not in the tool description.

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 short sentence with no filler words. It is front-loaded and easy to parse, though it is perhaps too terse to carry the behavioral detail needed for a 7-parameter tool with multiple modes.

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

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

For a tool with 7 optional parameters, three action modes, and no output schema or annotations, the description is too thin. It does not explain what distinguishes 'check', 'quick', and 'review', what the tool returns, or what prerequisites like continuity_token/client_session_id are for. The rich schema helps but the description itself is inadequate for complete context.

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 parameter descriptions are detailed (e.g., action enum semantics, reflection requirements, ownership token caveats). The tool-level description adds no additional parameter meaning, so the baseline of 3 applies.

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

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

The description states the tool is 'Unified self-recovery for stuck/paused agents,' which clearly identifies the domain and target condition. It does not use a strong action verb or explicitly distinguish itself from siblings like health_check or check_working_state, but the recovery intent is reasonably obvious.

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 stuck/paused agents' implies when the tool should be used. However, there is no explicit guidance on when to prefer self_recovery over health_check or check_working_state, nor any stated exclusions or alternatives, so the usage context is only implied.

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

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

With no annotations provided, the description carries the full disclosure burden. It usefully reveals that the tool returns a uuid and client_session_id to persist, and clarifies fork-lineage semantics for parent_agent_id. However, it does not disclose the notable default resume=true behavior (that the tool may rebind an existing identity rather than create a new one unless force_new is set), nor any persistence/side-effect characteristics.

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, zero filler, with the most actionable guidance (common case and return values) front-loaded before the edge-case clarification. Every sentence earns its place.

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

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

For a 17-parameter tool with no annotations and no output schema, a three-sentence description is thin. The schema picks up substantial slack with 100% parameter coverage, and the description covers the common case well, but gaps remain: resume-by-default behavior, relationship to the identity sibling, parameter interactions, and what distinguishes a session-provisioning call from a resume call are left implicit.

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

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

Schema coverage is 100%, placing the baseline at 3, and the description adds genuine semantic value beyond the schema: it identifies force_new as the key parameter in the common case and refines parent_agent_id's meaning to exclude same-workspace concurrent sessions. It also tells the agent which outputs to preserve, which is parameter-adjacent guidance the schema lacks.

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 ('starting a session') and positions it as the 'Primary workflow name' and 'Single entry point for new agents' per the schema description. This is clear, though it partially restates the tool name and does not explicitly differentiate from the sibling 'identity' tool, which appears closely related.

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 concrete usage direction: 'Common case: force_new=true alone — save the returned uuid and client_session_id' and an explicit exclusion for parent_agent_id ('for a real handoff from an exited predecessor, not for a session sharing the workspace with one still running'). It stops short of routing to alternatives (e.g., when to prefer the identity sibling or resume paths), so it's strong but not a full decision guide.

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 states the tool records to shared memory, but does not disclose what happens after the call (e.g., return value, readback behavior), whether the operation is destructive or idempotent, whether permissions are required, or what failure modes exist. For a persistent write operation, this is a significant gap.

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

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

Three compact sentences, with the core purpose first and the routing alternative immediately after. No filler or redundant restatement of the name. The implementation detail 'implemented by knowledge(action=\'store\')' earns its place by linking the tool to the underlying mechanism.

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 is adequate for a high-level understanding, but the tool has 13 parameters, no annotations, and no output schema. It does not explain what the caller should expect after invoking the tool, whether any parameters are effectively required for a meaningful store, or how this interacts with the sibling knowledge and update_finding tools beyond record_result. Given the complexity, the description is thinner than ideal.

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. The description reinforces the conceptual purpose of the parameters (durable knowledge, discovery, root cause, correction) but does not add any parameter-specific meaning beyond what the schema already 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 names a specific verb and resource ('recording a finding to shared memory') and explicitly distinguishes the tool from record_result by stating durable knowledge vs task/tool/test outcomes. It also clarifies the underlying implementation via knowledge(action='store'), leaving no ambiguity about what the tool does.

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 when-to-use guidance: 'Use for durable knowledge — a discovery, root cause, or correction.' It also names the alternative for other cases: 'For task/tool/test outcomes use record_result instead.' This is a clear and actionable routing rule.

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—but it discloses only EISV field semantics (ranges and provenance), not behavior. It omits side effects such as auto_export_on_significance (governance history export), include_memory_suggestions (KG lookup), identity gating hinted by require_strong_identity, and what the response looks like. The 'implemented by process_agent_update()' line is an implementation detail, not 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?

Roughly 70 words with the purpose front-loaded, but the 'implemented by process_agent_update()' clause is dead weight for an agent consuming the tool, and the EISV definitions are packed into one dense unbroken paragraph that is hard to scan. Information-dense but structurally unhelpful.

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

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

For a tool with 23 parameters, zero annotations, no output schema, and nested objects, the description covers only the EISV domain and omits the things an agent most needs: the call's outcome/return behavior, side-effect triggers, identity prerequisites, and sibling differentiation. The EISV semantics are thorough, but they constitute a small fraction of what a correct call requires.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real value beyond the schema: it defines the EISV conceptual model (E=Energy, I=Information Integrity, S=Entropy, V=Valence), their numeric ranges, and their provenance semantics—none of which appear in the schema, which merely references `eisv` in sensor_data. This grounds parameters like sensor_data, complexity, and epistemic_class in a shared vocabulary.

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?

"Primary workflow name for checking in state" is essentially a restatement of sync_state and never says what the call accomplishes (stores state? reports metrics? computes a response?). It also fails to differentiate from the confusingly similar sibling check_working_state. The detailed EISV field definitions give substance about what 'state' contains, which prevents a 1, but the core purpose remains vague and jargon-bound.

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 'primary workflow for checking in' phrase weakly implies a usage context, but the description provides no exclusions, no conditions, and no alternatives. With 13 siblings including check_working_state, record_result, and health_check, an agent has no basis for choosing sync_state over the near-identical check_working_state, nor for knowing 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?

No annotations are present, so the description must carry behavioral disclosure. It names the underlying mechanism and a key prerequisite, but does not disclose overwrite semantics, ownership token requirements, or response behavior. For a mutation tool, this is a notable transparency 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?

Two dense sentences front-load purpose and key constraints with no filler. Every sentence contributes actionable information, and the structure is easy 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?

With 13 optional parameters, no annotations, and no output schema, the description provides high-level orientation but omits critical operational details like ownership/session token requirements, supersession semantics, and what the caller receives. The schema descriptions compensate partially, but this tool is complex enough that the description alone is 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?

Schema coverage is 100%, so the baseline is informed. The description adds meaningful guidance by highlighting that discovery_id is needed and that status should be set when resolved or superseded, which connects to the superseded_by field. Other parameters are left to schema descriptions, which are already complete.

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

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

Clearly states it revises an existing finding in shared memory, names the underlying knowledge action='update', and identifies the key prerequisite. This differentiates it from store_finding (new findings) and knowledge (generic dispatcher).

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?

Indicates this is the primary workflow for revising existing findings and gives explicit guidance to set status when resolved or superseded. It does not explicitly exclude alternatives like store_finding, but the 'already in shared memory' phrasing implies the boundary.

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