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

With no annotations, the description carries the full burden and does well: it enumerates what each grant value authorizes (one commit, session storage, audit-only, storage off) and notes that unrecognized strings are recorded but do not authorize storage. It does not cover authorization requirements, idempotency, or error behavior, which leaves some gaps for a mutation/audit 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?

Front-loaded purpose sentence followed by a compact, flat list of grant semantics; every line adds information an agent needs and there is 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 two-parameter consent checkpoint with no output schema or annotations, the description covers the decision values and their consequences thoroughly. What remains unaddressed is the meaning/source of session_id and the shape of the result, though the latter is less critical here.

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

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

Schema description coverage is 0% and grant is a bare string with no enum, so the description's enumeration of the four valid values plus the fallback behavior is essential and well done. However, session_id — the other required parameter — receives no explanation of origin or format anywhere, so the description only partially compensates.

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 specific verb+resource ("Record the user's consent decision") and frames the call as "the consent checkpoint," which clearly separates it from commit/proposal siblings. It stops short of naming any sibling tool explicitly, so differentiation is inferred from semantics rather than stated.

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

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

It gives an explicit prohibition: "Do not send approve_run or approve_session on your own," plus the precondition that the value must be the user's choice from the approval dialog. What's missing is a pointer to the alternative tool when consent isn't yet appropriate (e.g., ecg_get_session).

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 usefully discloses idempotency ('No-op if it is already gone') and scope ('Does not delete stored facts'), which are real behavioral traits. But it omits permissions/auth needs, reversibility, and any indication of the result of the call.

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

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

Three short, front-loaded sentences with zero padding; the primary action leads and the two behavioral caveats follow. Every sentence earns its place.

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

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

For a simple 2-parameter cancel tool with no output schema, the description covers the essential behaviors (idempotency, non-destruction of facts). It is nonetheless incomplete on parameter meaning and on how it differs from the sibling discard tool, leaving real 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?

Schema description coverage is 0% and neither parameter (session_id, exchange_id) is explained in the description. The text refers vaguely to a 'staged proposal,' but does not clarify what session_id or exchange_id identify or how they relate to the dropped step.

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+resource ('Drop a staged proposal'), which is clear on its own. However, it does not differentiate itself from the sibling 'ecg_discard_proposal', which sounds nearly synonymous, so an agent cannot tell the two apart from the text alone.

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 on when to use this versus alternatives such as ecg_discard_proposal, nor any prerequisites (session/exchange state needed). The 'no-op if it is already gone' clause describes behavior, not when-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?

With no annotations, the description carries the full burden and does well: it discloses that this is a staging operation that does not persist durable memory, and that exchange_id comes from the prepare step. It omits idempotency/repeat-call behavior and any permission requirements, but the core write-vs-stage distinction is explicit.

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

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

Front-loaded with the purpose and the key non-durability fact, then details the workflow. Appropriately sized with no filler, though the trailing warning sentence is slightly fragmented from the main flow.

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 3-required-param mutation tool with no annotations and no output schema, the description covers the workflow adequately but leaves gaps: the shape/contents of the placements array and the effect of calling this repeatedly are not addressed.

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

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

Schema description coverage is 0%, so the description must compensate. It meaningfully documents exchange_id (the prep_id from ecg_prepare_placements) but leaves placements and session_id unexplained, so only one of three required parameters gets added meaning.

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 ('Stage') plus the resource ('the agent's chosen placement actions') and immediately clarifies the non-durable nature with 'Does not write durable memory.' It implies separation from siblings by referencing prepare and commit steps, though it doesn't name them as explicit 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?

Gives clear context: record merge/replace/drop decisions before the user approves via ecg_commit_step, and warns that dropped placements must not be sent later as approved. It names the downstream sibling but does not state when NOT to use it versus ecg_prepare_placements.

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

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

With no annotations, the description carries the full burden and does so well: it discloses refusal conditions (approve_session or unconsumed approve_run required), grant accounting (one successful commit consumes one grant, a failed commit does not), and supersede semantics (>=0.75 confidence supersedes and links supersedes; lower confidence or ambiguous target keeps both facts and opens a conflict). It also warns against hiding content in the approval dialog.

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?

It is a dense multi-paragraph block, but it is front-loaded with the core purpose and each paragraph adds distinct value (approval dialog, id provenance, grant accounting, supersede behavior). No sentence is filler, though the volume is on the heavy side.

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 mutation tool with no annotations and no output schema, the description covers preconditions, parameter meaning, and conflict/supersede outcomes. It stops short of describing what a successful commit returns (e.g., created fact ids, conflict references), but that is a modest omission given how much else is disclosed.

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

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

Schema coverage is 0%, so the description must compensate, and it explains exchange_id (= prep_id from prepare or a new id), messages ('provenance turns'), and placements (same fields as a candidate plus action and optional supersede_existing_fact_id/target_fact_id). Only session_id is left unexplained, which is a minor gap rather than a serious one.

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

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

It states a specific verb and resource ('Store approved facts for one exchange') and frames itself as 'the storage checkpoint', which is a precise scope. However, it never names or contrasts itself against the very similar sibling ecg_commit_placements, so the agent must infer the boundary from the schema and surrounding tools.

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

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

It implies usage through the workflow ('exchange_id is the prep_id from prepare, or a new id when committing placements directly') and states the preconditions for success (approve_session or an unconsumed approve_run grant). But it gives no explicit when-not or routing guidance against the sibling commit/prepare tools, leaving the alternative selection to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. It adds one useful trait beyond the schema — 'Do not store it later' signals the proposal should not be persisted — but it omits whether the discard is permanent/reversible, whether it requires permissions, and what happens to the associated session.

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

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

Three short sentences that are front-loaded with the discard intent. Slight redundancy between 'Drop it' and 'Do not store it later' keeps it from being maximally tight, but nothing is wasted.

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

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

For a mutation-style tool with no annotations, no output schema, and an undocumented parameter, the description is too thin. It doesn't clarify what a 'staged proposal' is, how session_id scopes the operation, or what the caller should expect afterward.

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 one required parameter (session_id) at 0% schema description coverage, and the description says nothing about what session_id represents or that it identifies the session whose proposal is being dropped. The description fails to compensate 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 verb 'Drop' plus the resource 'the staged proposal' make the core action clear, and 'discard_proposal' aligns with it. However, the framing is narrative ('The user declined...') rather than a declarative statement of what the tool does, and it doesn't explicitly distinguish itself from siblings like ecg_cancel_step.

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 context 'The user declined the staged proposal' implies the trigger condition, and 'Do not store it later' hints at the intent. But there is no explicit when-to-use guidance and no comparison to alternatives such as ecg_cancel_step or ecg_resolve_conflict, leaving usage implied 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?

No annotations are supplied, so the description carries the full behavioral burden. It helpfully discloses the return payload, that database and embeddings are reported as independent status objects with degradation isolation, and that it does not store facts. It omits whether starting a session creates or mutates server-side state, whether it is idempotent, and any auth or consent prerequisites.

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

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

Front-loaded with the core action, followed by return contents and then two sharp caveats. The enumerated return fields are justified because no output schema exists. The section is slightly list-heavy but each clause carries 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?

With no output schema, the description responsibly enumerates the return shape; with no annotations, it partially covers behavior via the no-facts-stored note and degradation semantics. For a one-parameter session bootstrap it is nearly complete, missing only explicit side-effect and prerequisite 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 0%, so the description must compensate, and it does: it clarifies that the single `path` accepts the project root or any file inside it, and explicitly warns not to pass a login secret. That is genuine semantic value beyond the bare `{"type": "string"}` schema, though it stops short of specifying absolute vs relative path form.

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 pair and resource: 'Start or resume the engineering-memory session for a project path.' An agent knows exactly what this does. It does not name or distinguish itself from any sibling tool (e.g., ecg_stats or ecg_approve_consent), which the rubric requires 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?

Usage is implied by 'Start or resume ... for a project path' and reinforced by 'This call does not store facts', which tells the agent not to expect persistence. However, there is no explicit when-to-use/when-not guidance and no named alternative among the 11 siblings, so the agent must infer sequencing (e.g., call this before ecg_commit_step).

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

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

With no annotations, the description carries the full burden, and it does disclose that only titles and ids are returned ('no bodies'), which is useful. However, it does not mention read-only safety, authentication needs, pagination, or other behavioral traits expected for a list operation.

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 short sentences, front-loads the primary purpose, and efficiently specifies the output limit. Every phrase 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 simple one-parameter list tool with no output schema, the description adequately covers scope and return shape, but it omits any explanation of the required session_id and gives no context about what a session represents, leaving a notable gap for 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 description coverage is 0% and the sole required parameter (session_id) is never mentioned or explained. The description does not compensate for the missing schema-level documentation, leaving the parameter's meaning and expected format unclear.

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 ('List') and resource ('conflicts') with the scope narrowed to 'open supersession or contradiction conflicts,' which clearly distinguishes it from sibling tools like ecg_resolve_conflict.

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 word 'open' implies when the tool is relevant, but no explicit guidance is given about when to use it versus ecg_resolve_conflict or other siblings, and no exclusions or prerequisites 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?

With no annotations the description carries the full burden, and it delivers solid behavioral context: scoring is against the repo, nothing is persisted, the proposal lives only in process memory, and abandoning it leaves no DB row. It stops short of covering authorization requirements, rate limits, or failure modes.

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 and the 'does not store' caveat are front-loaded in the first line, followed by dense but useful detail on candidate fields and the return shape. Nothing is obviously wasted, though the multi-clause enumeration is heavy for the space.

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

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

There is no output schema, and the description compensates by naming the return values (prep_id/exchange_id plus a per-candidate classification with matched titles and scores). Combined with the persistence caveat, an agent has enough to invoke and interpret the call; error and permission behavior are unaddressed.

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

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

Schema description coverage is 0% and the schema declares only two loosely typed params, so the description must compensate. It documents the candidate shape in detail (required title; optional body, fact_type, entities, confidence 0..1, action with an explicit value list) and notes unknown types are accepted. It leaves session_id unexplained, which keeps it just under a 5.

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

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

States specific verb+resource (score candidate facts, stage a proposal) and immediately scopes it with 'Does not store,' which distinguishes it from the sibling ecg_commit_placements. An agent can tell what it does and what it does not do without opening the schema.

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

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

Usage is only implied: staging followed by a commit/discard step is suggested by 'Does not store' and 'Abandoning it leaves no database row,' and the sibling set (ecg_commit_placements, ecg_discard_proposal) hints at the workflow. There is no explicit statement of when to choose this over the commit tool or what prerequisites exist, so it stays at the minimum-viable level.

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

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

No annotations exist, so the description carries the full burden and does so well: it discloses that nothing durable is written, that storage is deferred and conditional, and that consent gates the persistence. It stops short of covering idempotency or what happens if no commit follows.

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

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

Three short, front-loaded statements with no filler; the negative constraint appears in the first sentence and the message format is compactly specified. The mid-text code fence breaks flow slightly but 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 staging tool with a nested message payload and no output schema, the definition covers the deferred-write model, consent gating, and message format. It leaves session/exchange identifier meaning and any size limits or idempotency behavior unaddressed.

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 documents the shape and semantics of the `messages` parameter in detail ('{"role": "user"|"assistant", "content": "..."}'), but says nothing about `session_id` or `exchange_id`, leaving two of three required params undocumented.

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+resource ('Stage conversation turns') and immediately scopes it with 'Does not write durable memory', which distinguishes it from the persistence side of the sibling set. It ties itself to ecg_commit_step, giving partial sibling differentiation, though it doesn't distinguish against staging-adjacent tools like ecg_discard_proposal.

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

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

Explicitly states the persistence condition ('Full text is stored only if a later ecg_commit_step succeeds under consent'), which tells the agent when this tool's effect becomes durable and implies the commit dependency. It lacks an explicit when-to-use/alternative routing statement, but the context is clear.

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

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

With no annotations, the description carries the full burden and does so well: it discloses that history is kept, the losing fact is marked superseded and linked, and nothing is ever deleted, plus the exact effect of each resolution value. Auth/permission requirements and rate limits are not mentioned, which is the only 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?

Front-loads the purpose, then explains the resolution choices and the history-preservation behavior in a tight, well-ordered block. It is appropriately sized, with only light redundancy in the 'old'/'existing' synonym listing.

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 destructive-looking mutation with no annotations and no output schema, the description supplies the key behavioral facts an agent needs (choice semantics, supersede-not-delete). It stops short of stating permission or session requirements, but is otherwise complete.

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

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

Schema coverage is 0%, so the description must compensate, and it does: it fully enumerates the resolution values (new/old/existing/both) with their semantics and explains that conflicts is a list of ids from ecg_list_conflicts. Only session_id is left undocumented, which is a minor omission.

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 ('Resolve open conflicts') and names ecg_list_conflicts as the source of the ids, which helps separate it from the sibling that only lists them. It is clear about what the tool does, though it doesn't explicitly differentiate from all the other mutation siblings.

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

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

Provides clear context for using it: it is 'the user's choice, not a silent overwrite', and the conflicts input comes from ecg_list_conflicts, implying the list-then-resolve workflow. No explicit when-not condition or prerequisite is stated, but the usage context is well established.

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

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

With no annotations, the description carries the full burden and does well: it discloses server-side ranking, that no fact-id list is accepted (and why a caller cannot widen an approval), cluster labeling, and the token/preview fallback to titles-only. It omits permission/auth requirements and error behavior, keeping it short of a 5.

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

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

Four tight sentences with the purpose front-loaded and each sentence adding new information (ranking, constraint, output shape, fallback). Some information is dense jargon, but there is little waste.

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

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

The output schema covers return values and the description usefully explains cluster labeling and the preview fallback. However, with 0% parameter coverage, the unexplained session_id and limit leave genuine gaps for an agent trying to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate, and it only partially does: it explains how query and entity_names drive server-side ranking but says nothing about session_id's role or the meaning/effect of limit (default 8). Half the parameters remain undocumented.

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 concrete action and resource ('Return the smallest fact neighborhood for query') and adds a distinguishing claim, 'This is the only body export,' which separates it from the session/placement siblings. The scope is clear, though the domain jargon ('fact neighborhood', 'body export') requires some inference and no sibling is named directly.

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

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

The description implies usage through 'This is the only body export' and the ranking/preview behavior, but it never states when to prefer this over ecg_get_session or the placement tools, nor any prerequisites. Usage must be inferred rather than read.

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, but it does disclose the key traits: the operation is read-only and fact bodies are excluded from the response, so an agent knows no content is returned. It omits permissions requirements, session-state prerequisites, and whether counts are eventually consistent.

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

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

Two sentences, front-loaded with the operation's nature and followed by the exact metric list. The metric enumeration is dense but each item earns its place by defining the return payload; nothing is padded.

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

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

There is no output schema, but the description enumerates the returned counts (exchanges, active/superseded/total facts, edges, entities, open conflicts) and states what is excluded, which is the information an agent needs. The only real gap is the undefined session_id.

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

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

Schema description coverage is 0% and session_id is undocumented in both schema and description, so the description does not compensate for the gap. However, with a single self-evident identifier parameter, the practical risk is low, putting this near the baseline rather than below it.

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

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

The description names a specific verb+resource ('Read-only counts for the session's repository') and enumerates exactly which metrics are returned, which distinguishes it from diagnostic siblings like ecg_list_conflicts and ecg_search_context. It stops short of explicitly naming an alternative sibling, so it is clear but not fully differentiated.

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 statement of when to call this versus siblings — e.g. whether it replaces or complements ecg_list_conflicts for conflict counts, or whether the session must be committed first. Usage is only inferable from the metric list; no conditions or exclusions are given.

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