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

With no annotations, the description must carry the full behavioral burden. It hints at idempotency via 'event-ledger idempotency' and scope-limit via 'bounded', but it does not disclose mutation side effects, permissions required, reversibility, or what apply mode changes.

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 front-loaded and free of filler, so there is no wasted text. However, its telegraphic jargon reduces clarity for a tool with this much behavioral and parameter complexity.

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

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

An output schema exists, so return values need not be described. But for a five-parameter mutation tool with no annotations and no schema descriptions, the definition omits parameter meanings, mode semantics, and safety-relevant behavior.

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

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

Schema description coverage is 0%, so the description must compensate for all five parameters. It only obliquely implies the plan/apply distinction for 'mode'; critical fields such as expected_plan_digest, repair_temporal_projection, run_key, and items remain undefined.

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 action ('Plan or apply') and resource ('bounded historical records'), so the core purpose is clear. It does not explicitly differentiate itself from siblings such as erinys_batch_save or erinys_save, which an agent would need to distinguish backfill from bulk insert.

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

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

There is no guidance on when to use this tool versus erinys_batch_save, erinys_save, or other siblings, nor when to choose plan mode versus apply mode. The phrase 'plan or apply' only implies a workflow; it does not state prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It says the backup is 'consistent' and returns metadata, but does not explain whether files are overwritten, where the default backup is written, permission requirements, or what 'consistent' means operationally.

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

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

The description is a single concise sentence with zero wasted words, and the primary action is front-loaded. It is appropriately sized for a simple backup tool.

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

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

The tool is simple, has one optional parameter, and an output schema exists, so return-value explanation is not required. However, with no annotations and an undocumented path parameter, the description is only minimally adequate 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?

The only parameter, path, has 0% schema description coverage, and the description does not clarify its meaning. It does not state whether path is a destination file, directory, or optional override of a default location, leaving the agent to infer from the parameter name alone.

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

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

The description states a specific verb and resource: creates a SQLite backup. It also mentions returning backup metadata, making the core action clear and distinguishable from memory-oriented sibling tools, though it does not explicitly compare itself to 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?

The description gives no explicit guidance on when to use this tool versus alternatives, nor does it mention prerequisites or exclusions. Backup usage is implied by the name and purpose, but the agent receives no selection criteria.

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

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

With no annotations, the description carries the full behavioral burden. 'Bulk-add' implies mutation and 'automatic similarity linking' hints at a side effect, but the description does not say whether links are always created, whether the operation is atomic, what permissions are needed, or what happens on partial failure.

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 definition is a single front-loaded sentence with no filler, but its extreme brevity leaves most of the calling contract unexplained. It is efficient but arguably under-sized for a bulk mutation with linking side effects.

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?

An output schema exists, so return values need not be described. But for a batch mutation with no annotations and an untyped item array, the description is missing critical details: item structure, auto-link behavior, and failure semantics.

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 itself leaves 'items' as an untyped array of arbitrary objects. The description does not explain the shape of an item or clarify what auto_link controls, adding only marginal meaning beyond the field names.

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 gives a specific verb and resource ('Bulk-add observations') and mentions a distinctive behavior ('automatic similarity linking'). However, it does not differentiate this tool from the closely named sibling erinys_save, leaving the agent to infer that this is the batch variant.

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

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

There is no guidance on when to use this instead of erinys_save, erinys_link, or erinys_reinforce. The description does not state prerequisites, batching limits, or when auto-linking should be disabled.

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 implies an operation that produces insight but does not disclose whether it writes to storage, is reversible, requires permissions, or has side effects on the two observations.

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 front-loaded and contains no filler. It is efficient, though its brevity contributes to the missing usage and behavioral context.

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

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

An output schema exists, so return values need not be explained, but the description still leaves the core operation, side effects, and sibling selection ambiguous. For an agent choosing among 28 Erinys tools, this is not sufficient 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 0%, so the description must compensate. It implies obs_a_id and obs_b_id are observations but does not explain ID meaning, whether order matters, or what relationship between the two observations is expected.

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 verb ('collide') and resource ('two observations'), but 'collide' is undefined jargon and 'generate insight' is vague. It does not clarify how this differs from related siblings such as erinys_link, erinys_traverse, or erinys_conflict_check.

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

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

There is no guidance on when to use this tool, when to prefer alternatives, or what preconditions must hold. The word 'manually' hints at an explicit invocation but does not explain the context that should trigger 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?

With no annotations at all, the description carries the full disclosure burden, and it discloses almost nothing. It does not say whether the check is read-only, whether it flags or resolves conflicts, how far it searches for contradictions, or whether it costs anything — all material for a tool an agent may call speculatively.

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?

One short sentence, front-loaded, with no filler — but the brevity here is under-specification rather than economy. It reads as a fragment of a definition rather than a complete one.

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?

An output schema exists, so return values need not be explained, but everything else is missing: no annotations, no parameter documentation, no scope of the comparison. For a tool in a dense 28-sibling namespace, that is not enough to call 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?

The single parameter observation_id has 0% schema description coverage, and the description does not mention it. It is left unstated whether the id names the observation being checked or the one being checked against, which is the crux of interpreting the result.

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 verb ('detect') and a resource ('contradicting observations'), which is more than a restatement of the name. However, it never says what the check is run against — one observation versus the whole store, or a pair — leaving the actual operation ambiguous.

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 invoke this versus siblings that clearly overlap in the same memory-hygiene space, such as erinys_collide, erinys_supersede, or erinys_eval. The agent gets no trigger condition and no exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not indicate what 'context' actually contains, what the default limit of 20 means for truncation, whether results are ordered or paginated, or what the intended_use parameter changes — even though 'recent' hints at recency ordering, that is not stated.

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

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

A single front-loaded sentence with no filler, so nothing is wasted. But the brevity is under-specification rather than efficiency, given three undocumented parameters and a meaningless default for intended_use.

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?

An output schema exists, so return-value explanation is not required. Still, for a tool with no annotations and 0% parameter coverage, the description should explain the semantics of 'session context', the limit behavior, and intended_use — none of which are covered.

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 largely does not. It implies 'project' is the scope but says nothing about 'limit' (default 20) or the opaque 'intended_use' parameter (default 'context'), which is the most ambiguous field and gets no explanation at all.

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 verb ('Get') and a resource ('recent session context') scoped to a project, which is more than a restatement of the name. However, with siblings like erinys_session_summary, erinys_recall, and erinys_timeline, 'session context' is not clearly distinguished from a summary or a timeline, so an agent cannot confidently pick this tool over those.

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

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

There is no guidance on when to use this tool versus erinys_session_summary, erinys_recall, or erinys_timeline, and no stated preconditions (e.g. must a session be started first via erinys_session_start?). The agent must infer the routing decision entirely.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose one important trait: dependent rows are cascade-deleted via FK rules. It stops short of stating irreversibility, required permissions, confirmation expectations, or exactly which relations cascade, which matter a great deal for an unannotated destructive 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?

A single compact sentence with the action and the cascade consequence front-loaded; every word earns its place and 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?

An output schema exists, so return values need not be described, and the cascade note covers the key side effect. The remaining gap is disambiguation from sibling deletion-like tools and parameter clarification, minor but not negligible for a destructive operation.

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

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

Schema description coverage is 0%, so the single `id` parameter is undocumented in the schema itself. The description only indirectly clarifies it by saying an observation is deleted, implying `id` is an observation identifier, but it never states the expected format or scope (e.g., global vs session-local).

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 ("Delete an observation") and adds a meaningful behavioral detail about cascading dependent rows. However, it does not differentiate itself from close siblings such as erinys_forget and erinys_prune, which an agent could easily confuse with this one.

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 use this tool versus erinys_forget, erinys_prune, or erinys_supersede, all of which plausibly overlap with deletion semantics. No prerequisites, confirmation requirements, or exclusions 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?

No annotations are provided, so the description carries the full burden, yet it says nothing about whether distilling mutates the original observation, creates a new record, is reversible, or requires the observation to be in a particular state. Only one short sentence of pure intent is offered.

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 short sentence with no wasted words, but the brevity here reflects under-specification rather than disciplined editing; there is no front-loaded usage or scope 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?

An output schema exists so return values need not be described, but for an unannotated two-parameter mutation-like tool in a large sibling family, the definition omits the essentials: what distillation produces, how level values behave, and what happens to the source observation.

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

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

Schema description coverage is 0%, so the description must explain both parameters, but it only gestures at them: "observation" loosely maps to observation_id and "higher abstraction level" to level without naming valid values (the default "abstract" is not mentioned or enumerated). No compensating detail is supplied.

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 verb ("distill") and a resource ("observation") plus a direction ("higher abstraction level"), so the general intent is inferable. But "distill" and "abstraction level" are never defined, and nothing distinguishes this from abstractions produced by siblings such as erinys_dream or erinys_session_summary.

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 distill versus recall, summarize, dream, or supersede, and no prerequisites or exclusions. The agent must guess from the sibling list alone which tool is appropriate.

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. 'Run' suggests an operation that may modify memory state, but it discloses nothing about side effects, destructiveness, permissions, or whether collisions mutate or merely report—all critical for an agent choosing among mutation-capable siblings.

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?

One compact sentence with no filler, but the brevity comes at the cost of substance—the jargon is front-loaded without unpacking it.

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?

Return values are covered by the existing output schema, but for an unannotated batch operation with an undocumented parameter, the description leaves out too much: no behavior, no side-effect profile, no when-to-use guidance.

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% and the single parameter max_collisions is never mentioned in the description. The schema reveals only its type and default of 10, so the meaning of a 'collision', the cost of raising it, and its effect on output 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?

It names a verb plus resource ('Run Dream Cycle') and the core operation ('batch collision of candidate memory pairs'), but 'Dream Cycle' and 'collision' are unexplained jargon, and the description does not distinguish it from the closely named sibling erinys_collide.

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 run this versus erinys_collide, erinys_batch_save, or erinys_distill, no prerequisites, and no note on cost or frequency. The agent must guess from the tool name alone.

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

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

With no annotations, the description carries the full disclosure burden, yet it never says whether evaluation mutates stored memory, how expensive it is to run, or what triggers it. "Self-evaluate" could be read-only or could rewrite scores; the description leaves that ambiguity unresolved.

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?

One short sentence with no filler and no repetition, so it is efficient, but it is efficient by omission rather than by discipline. Nothing is front-loaded beyond the bare action.

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 means return values needn't be described, but the description still omits the parameter meaning, the mutation/cost profile, and how this differs from nearby diagnostics. For a tool in a 28-tool namespace, that leaves too much to inference.

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 single optional `project` parameter has 0% schema description coverage and is never mentioned in the description, so the agent has no idea what it scopes or what omitting it means. This is the one parameter that needed compensating text and got none.

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?

"Self-evaluate memory quality" gives a verb and resource, so the action is inferable, but "LOCOMO-inspired metrics" is jargon that doesn't tell an agent what is actually measured or produced. Nothing distinguishes it from sibling diagnostics like erinys_stats or erinys_conflict_check.

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, when-not-to-use, or alternative is named despite 27 siblings including erinys_stats, erinys_conflict_check, and erinys_session_summary that plausibly overlap. The agent must guess whether this is a diagnostic, a scoring pass, or a maintenance 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?

No annotations are provided, so the description carries the full behavioral burden. It implies an export/read operation and mentions markdown wikilinks, but does not state whether it is read-only, what scope of observations is exported, whether a project filter changes the output, or if there are side effects or permission requirements.

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

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

The description is a single front-loaded sentence with no wasted words. It is efficient, though arguably under-specified for a tool with two undocumented parameters and no annotations.

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?

An output schema exists, so return values need not be explained. However, with no annotations, 0% schema description coverage, and two parameters whose behavior is not clarified, the description is not complete enough for an agent to invoke the tool confidently.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It indirectly references a markdown format but does not explain the 'format' parameter's allowed values or the 'project' parameter's filtering role at all.

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 ('Export') and resource ('observations') plus a format detail ('markdown payload', Obsidian-compatible wikilinks). It is clear what the tool produces, but it does not distinguish itself from siblings like erinys_backup or erinys_recall, which could also relate to exporting or retrieving data.

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

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

There is no guidance on when to use this tool versus alternatives such as erinys_backup, erinys_recall, or erinys_get. No prerequisites, exclusions, or contextual triggers are mentioned.

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: it discloses propagation to distilled descendants, leaf-first deletion inside a single transaction, which substrates are hit (observations/vec/FTS via triggers/edges/collisions via CASCADE), NO ACTION FK resolution, and the safe dry_run default. It also honestly scopes out what it will NOT verify (Obsidian vault lazy-removal on next export, .bak backups retained by design), which is exactly the kind of caveat an agent would otherwise get wrong.

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?

Information-dense and front-loaded: identity and mechanism first, propagation semantics next, the erinys_delete contrast and out-of-scope caveats last. Slight redundancy around 'closure' and very dense parenthetical substrate lists cost it a point, but no sentence is filler.

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

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

An output schema exists, so return values (closure and membership-test result under dry_run) need not be spelled out. Given a destructive, cross-substrate operation, the description covers mechanism, side effects, safety default, and exclusions; the only residual gap is the meaning of the required 'id' field.

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 fully explains dry_run's default-true and non-destructive behavior, which is the higher-risk parameter, but it never says what 'id' identifies (presumably an observation id, inferable only from context). Partial compensation leaves a real gap on the required parameter.

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

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

The opening line names a specific verb+resource+scope: verified forgetting that deletes an observation and its distilled derivatives across all DB substrates, with membership-test proof of absence. It explicitly contrasts with the sibling erinys_delete ('子を持つ親も忘れられる'), so an agent can route between the two without opening either schema.

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

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

It names the alternative (erinys_delete) and the discriminating condition (parent-with-children / closure resolution), and states that dry_run is the default path that only reports. It does not cover other plausible alternatives such as erinys_prune or erinys_supersede, so the guidance is clear but not exhaustive.

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. It does add one real behavioral fact — content is returned in full, not truncated — but says nothing about what happens when the ID does not exist, whether the read has side effects, or any access constraints.

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

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

A single sentence with the action and its distinguishing property front-loaded; nothing is wasted or 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?

An output schema exists, so return shape needn't be described. But with no annotations and a fully undocumented `intended_use` parameter, the definition leaves gaps an agent must guess at — notably the effect of that parameter and not-found behavior.

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 only partly does: 'by ID' glosses the required `id`, but the second parameter `intended_use` (default 'context') is entirely undocumented in both schema and description. An agent has no basis for setting or omitting 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?

States a specific verb and resource: 'Get a single observation by ID', and adds a meaningful qualifier ('full content, untruncated') that signals contrast with the truncating siblings like erinys_search or erinys_recall. It never names those siblings explicitly, so differentiation is implied 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?

The 'by ID' framing implies this is the direct-lookup path rather than a query path, which is usable context. However, there is no explicit 'use this instead of erinys_recall/erinys_search when...' guidance and no prerequisites or exclusions, leaving the agent to infer routing among 27 siblings.

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 does disclose the traversal mechanism (parents first, distilled_from as fallback) and implies a bounded read. However, it never states that the operation is read-only, what happens when max_depth truncates the chain, or how cycles are handled — meaningful gaps for a graph walk.

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

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

Two short sentences, front-loaded with the provenance-visibility framing followed by the mechanism. Efficient, though the untranslated Japanese and the opaque 'VMG Provenance Visibility' label add noise for a non-Japanese reader.

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?

An output schema exists, so return values need not be explained, and the traversal mechanism is covered. What is missing for a 2-parameter graph tool is the meaning of id and max_depth plus truncation/cycle behavior — and the description being Japanese-only reduces usability for agents reading the English title and 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 0% and neither parameter is mentioned: 'id' is never identified as the memory to trace, and 'max_depth' (default 10) is never explained as the traversal bound. The description's talk of a chain implies limits but gives no semantics for either input.

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: it walks a memory's provenance in the ancestor direction and composes a lineage-complete chain via provenance.parents with a distilled_from fallback. That is far more specific than a restated name, but it never distinguishes itself from nearby siblings such as erinys_traverse or erinys_timeline, which an agent could easily confuse with ancestry traversal.

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

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

There is no guidance on when to call this versus erinys_traverse, erinys_context, or erinys_timeline, and no prerequisites are stated. The agent must infer the selection rule from the description alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a mutation but never says whether the call is idempotent, what happens if source_id or target_id do not exist, whether duplicate edges are rejected, or whether creation is reversible. That is a substantial gap for a write 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?

One short sentence, well front-loaded with the verb, with zero padding. Its brevity, however, reflects under-specification rather than disciplined concision.

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?

An output schema exists, so return values need not be explained. But for a 4-parameter mutation tool with no annotations and 0% schema descriptions, the definition leaves an agent without enough to call it confidently or handle failure cases.

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% across four parameters. 'Typed' hints that relation carries a type label, but no valid relation values are given and the weight parameter is never mentioned at all. The description does not compensate for the near-empty 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?

States a specific verb and resource: 'Create typed edge between observations.' The agent knows this builds a relation between two existing nodes. It does not name a sibling or contrast with erinys_supersede or erinys_save, but the core action 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 on when to link versus when to save a new observation, supersede, or reinforce. Among 27 siblings there are several adjacent tools, and the description offers no routing criteria or prerequisites.

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

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

With no annotations, the description carries the full burden, yet it never states that pruning removes data permanently, whether it is reversible, what permissions are required, or whether it touches related records. 'Decayed' hints at a decay-score heuristic, but the destruction semantics of a mutation tool remain undisclosed.

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 single front-loaded sentence with no filler, but the brevity comes at the cost of under-specification rather than efficiency. Space exists for the destructive/dry-run distinction that was left out.

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, so that is not a gap. However, for a data-destroying tool with zero annotations and zero schema descriptions across two parameters, the definition omits reversibility, scope of deletion, and the dry_run safety default — an agent cannot safely invoke it on the text alone.

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

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

Schema description coverage is 0%, so the description must compensate. 'Below threshold' clarifies what the threshold value controls, but the dry_run parameter — the most safety-relevant one, defaulting to true — is never mentioned in the description, leaving the simulate-vs-execute behavior unexplained.

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 gives a specific verb ('prune') and resource ('decayed observations') plus a selection condition ('below threshold'), so the agent knows it is a threshold-driven cleanup rather than a general delete. It does not distinguish itself from close siblings such as erinys_delete or erinys_forget, leaving the prune-vs-delete distinction to inference.

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 run this versus erinys_delete, erinys_forget, or erinys_supersede, and no prerequisites or preconditions are stated. The agent must guess the intended workflow context entirely.

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, yet it only implies recency ordering. It does not say whether results are session-scoped, project-scoped, capped, or ordered, nor whether the call has side effects. An output schema exists, so return values need not be explained, but the retrieval behavior remains opaque.

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 efficient and front-loaded with the verb, but its brevity comes from under-specification rather than tight editing; nothing about the phrasing earns its place on its own.

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 three undocumented parameters, no annotations, and a crowded sibling namespace, one generic sentence is not enough. The output schema covers return values, but the input contract and selection criteria are left entirely to inference.

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% across three parameters, so the description must compensate and does not. It never explains 'limit', the 'project' scope filter, or the cryptic 'intended_use' parameter whose default is 'context' — a value an agent has no way to interpret.

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 'recall' and object 'recent observations' give a rough sense of purpose, but 'for context' is vague and the description never distinguishes this from siblings like erinys_get, erinys_search, erinys_context, or erinys_timeline, which all plausibly retrieve stored items.

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 indication of when to call this versus erinys_search or erinys_context, no prerequisites, and no statement about what 'recent' means in scope. The agent must infer usage entirely from the terse sentence.

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 discloses that access_count and last_accessed are updated, but does not state whether access_count is incremented or overwritten, whether the observation must already exist, whether the operation is idempotent, or what permissions are needed.

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

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

The description is a single front-loaded sentence with no filler. Every part of the sentence communicates the action and the fields being changed.

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 is simple, with one required parameter and an output schema, and the description conveys the core operation. However, for a mutation with no annotations, it leaves out important behavioral details such as increment semantics, existence requirements, and side effects.

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

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

Schema description coverage is 0%, and the description never mentions observation_id or explains its expected meaning beyond the parameter name. With only one parameter the invocation is still inferable, but the description does not compensate for the missing schema documentation.

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 action and mechanism: reinforcing an observation by updating access_count and last_accessed. This distinguishes it reasonably well from generic siblings like erinys_update or erinys_get, though it does not explicitly name those 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?

The description does not say when to use this tool versus erinys_update, erinys_recall, or other observation-related siblings. Usage is implied by the term 'reinforce', but there are no explicit conditions, exclusions, or alternatives.

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

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

With no annotations, the description carries the full burden and does substantial work: it documents the principal resolution chain (explicit → ERINYS_PRINCIPAL → 'unknown'), that provenance is recorded in VMG, and that writes outside allowed_projects/allowed_scopes are rejected with POLICY_DENIED while unset gates allow unconditional writes. That is real mutation-safety context. It stops short of stating whether a save with an existing topic_key overwrites, deduplicates, or errors.

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 one-line purpose is front-loaded, followed by two focused blocks on principal and the access gate; no sentence is padding. The mixed Japanese/English phrasing and embedded version labels (P0-7) add mild noise but do not obscure meaning.

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?

An output schema exists, so return values need not be explained, but for a 12-parameter write tool with zero schema descriptions the definition is not complete enough. Nine parameters, including the key identity fields topic_key and session_id, are left for the agent to guess at.

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% across 12 parameters, so the description must compensate and it largely does not. It covers only principal, allowed_projects, and allowed_scopes; title, content, type, scope, project, metadata, topic_key, session_id, and source_class are entirely undocumented, including the meaning of topic_key and source_class, which are non-obvious.

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: 'Save a structured observation to ERINYS memory.' An agent immediately knows this is the single-record write path. It does not, however, contrast itself with the very similar erinys_batch_save or erinys_update siblings, leaving the boundary implicit.

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 explains the conditional access-gate behavior (explicit arg > env > None) and the POLICY_DENIED outcome, which is useful. But it never says when to choose this tool over erinys_batch_save (multi-record) or erinys_update (mutating an existing memory), so selection among siblings is left 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 implies a write/persistence operation but says nothing about idempotency, deduplication, whether session_id/project affect storage, permission requirements, or what is returned; 'track intent and goals' is the only extra hint.

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 with no waste, but it is under-specified rather than concise — the brevity comes at the cost of the routing and parameter detail an agent needs.

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?

An output schema exists, so return values need not be explained. But for a mutation tool with zero annotations and three undocumented parameters, the description omits the behavioral and parameter context an agent needs to call 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% for three parameters, so the description must compensate and it does not. 'User prompt' loosely maps to content, but project and session_id receive no explanation of format or effect anywhere.

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 ('Save a user prompt') plus intent ('track intent and goals'), which is clearer than a bare 'save'. However, it never distinguishes itself from close siblings like erinys_save or erinys_batch_save, so an agent must infer the difference.

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 erinys_save, erinys_batch_save, or erinys_session_summary, and no prerequisites or exclusions. The agent is left with only the generic 'save a prompt' framing.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose useful gate semantics (precedence of explicit args over env vars, out-of-allowlist rows excluded, global scope always visible, default returns everything when unset), which is genuinely non-obvious. But it says nothing about ranking/score fusion behavior, pagination, or the meaning of the remaining eight parameters, leaving the mutation-free but complex search behavior largely opaque.

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 lead sentence is well front-loaded and wastes nothing. The following block is dense, run-on, and switches abruptly into Japanese mid-definition, which harms scannability and consistency with the rest of the toolset's naming conventions.

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?

An output schema exists, so return-value explanation is not required, but for a 10-parameter tool with zero schema description coverage and no annotations, the description is far too thin on parameter meaning and result-shaping behavior (limit, metadata_filter, include_distilled, include_anti_patterns) to let an agent invoke it confidently.

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% across 10 parameters, so the description must compensate and it only does so for two (allowed_projects, allowed_scopes). Nothing explains query, limit, project, principal, intended_use, metadata_filter, include_distilled, or include_anti_patterns, all of which are non-obvious and undocumented anywhere else.

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

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

The first sentence names a concrete technique (RRF hybrid search over FTS5 keyword plus vector similarity), so the verb is specific. However, it never says what is being searched (memories? session records? documents?) and gives no differentiation from siblings like erinys_recall, erinys_context, or erinys_get, which plausibly also retrieve stored content.

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 prefer this over erinys_recall, erinys_context, or erinys_get, and no conditions or exclusions. The only situational guidance is about the access gate, not about tool selection, so an agent must guess which retrieval sibling to call.

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. "End" implies a mutation, but the description never says whether session data is destroyed, whether ending is reversible, whether an in-progress state is flushed, or what preconditions exist. An output schema exists, so return values needn't be described, but mutation semantics remain undisclosed.

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 one-sentence description is front-loaded and free of padding, so nothing is wasted. The terseness crosses into under-specification rather than efficiency.

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?

A mutating lifecycle tool with zero annotation coverage, zero schema descriptions, and a large, overlapping sibling set — the description supplies almost none of the context needed to invoke it confidently. The presence of an output schema removes only the need to describe return values.

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% for both parameters. The single word "optional" hints at the default for summary, which is already visible in the schema, while the required `id` is never characterized (session identifier? title? prefix?) and the summary's purpose (persisted for later recall?) is left entirely implicit.

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 ("End a session") that an agent can act on immediately. It does not, however, distinguish itself from close siblings like erinys_session_summary or erinys_session_start, so the agent must guess which session-terminating or session-inspecting tool fits.

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 end a session versus calling erinys_session_summary first, nor any prerequisite (must the session be active? does it need to be the current session?). With 29 sibling tools, the absence of any routing hint is a real gap.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about what a session is, whether starting one is persistent or scoped, what happens if a session already exists, or what side effects occur. Only the bare notion of a state-creating action is 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?

A single front-loaded sentence with no wasted words, but it is under-specified rather than concise—there is nothing for the agent to act on beyond the tool name.

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?

An output schema exists so return values need not be described, but with zero annotations, 0% parameter coverage, and two required parameters, the definition leaves the agent without enough context to call this correctly—especially the meaning of id and project.

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% across three parameters: id, project, and directory have no descriptions anywhere. The description does not explain what id identifies, whether project must match an existing project, or what directory controls.

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+resource pair ("Start" + "session") is identifiable, but "session" is never defined in a system with 28 siblings, and the description does nothing to distinguish this from erinys_session_end or erinys_session_summary. An agent must infer what a session represents here.

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

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

There is no guidance on when to start a session versus using erinys_session_end or other lifecycle tools, no prerequisites, and no note on whether a session must be started before erinys_save/erinys_recall calls. Usage is entirely implied.

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

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

No annotations are provided, so the description carries the full behavioral burden. It mentions saving a summary and the content structure, but omits whether this overwrites existing data, what permissions are required, and how the optional session_id affects the write. For a mutation tool with no annotation coverage, 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?

The description is a single, front-loaded sentence with no wasted words. It is appropriately concise, though it may be too terse given the lack of annotations and parameter documentation.

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?

An output schema exists, so return values need not be explained. But the description is incomplete for a three-parameter mutation tool with no annotations and zero schema descriptions. It should at minimum cover required fields, session_id behavior, and how this tool relates to nearby save/session tools.

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 partially explains the 'content' parameter via the Goal/Discoveries/Accomplished structure, but leaves 'project' and 'session_id' completely undocumented, including what session_id null means.

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

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

The description uses a specific verb and resource: 'Save ... end-of-session summary.' It also names the expected content sections (Goal/Discoveries/Accomplished). However, it does not distinguish this tool from siblings like erinys_save, erinys_session_end, or erinys_batch_save.

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 'end-of-session' implies the usage context, so an agent can infer this is for wrapping up a session. But there is no explicit guidance on when to prefer this over erinys_save or erinys_session_end, and no exclusions or 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?

No annotations are provided, so the description carries the full behavioral burden, yet it only lists output contents. It never states that the call is read-only/side-effect free, whether it is cheap or expensive on a large database, or how 'health' is determined.

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 single terse fragment with no wasted words and the key noun front-loaded, but the terseness comes at the cost of under-specification rather than efficient information density.

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?

An output schema exists, so return values need not be explained, but with zero annotations and zero parameter documentation the definition leaves the agent without guidance on safety, cost, or the meaning of the 'project' argument. For a diagnostic tool with a filtering option, more context is needed.

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% for the single optional 'project' parameter, and the description only hints at it via the phrase 'project breakdown'. It does not say whether passing 'project' filters the stats to one project or changes the shape of the result, leaving the parameter's effect undocumented in both places.

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 fragment 'Database statistics: observation count, project breakdown, health' names the resource (database stats) and enumerates what is reported, so an agent can tell it apart from memory-mutation siblings like erinys_save or erinys_search. It is clear but not framed as a sentence with a verb, and no sibling is explicitly named as the alternative.

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 alternatives, no prerequisites, and no exclusions. An agent must infer that this is a diagnostic/introspection tool used before or after other operations.

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 entire behavioral burden. It does not say whether the old observation is deleted, archived, or retained in lineage (erinys_lineage exists as a sibling), whether the operation is reversible, what permissions are required, or what happens if old_id does not resolve. Only the mutation itself is implied.

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?

One short sentence with no filler, so there is nothing to trim. However, it is under-specified rather than genuinely concise — the terseness comes at the cost of information the agent needs, and the sentence does not front-load scope constraints.

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 three-parameter required mutation with no annotations and zero schema descriptions, the description is far too thin. The presence of an output schema excuses it from explaining return values, but it still omits the fate of the old record, lineage behavior, and error conditions that matter for a supersede operation.

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

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

Schema description coverage is 0%, so the schema gives only names and types. The description loosely maps 'old_id' to the old observation and 'new_content' to the updated fact, but 'reason' is entirely unexplained and no format, length, or constraint hints are offered for any parameter.

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 ('supersede') and its object ('an old observation') and implies a replacement fact. It does not distinguish supersede from erinys_update, erinys_forget, or erinys_reinforce, so the agent is left inferring that this is a replacement rather than an update or removal.

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

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

There is no guidance on when to use supersede rather than erinys_update or erinys_reinforce, no prerequisites (e.g., old_id must already exist), and no mention of erinys_conflict_check as a related tool. The agent must infer the selection criteria from the one-line 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?

No annotations are provided, so the description carries the full burden. It implies a read-only temporal query, but does not state whether superseded facts are included, how null as_of behaves (current time?), what permissions are required, or how results are ordered. The as-of framing is genuinely useful context, but major behavioral gaps remain for a tool with zero annotation coverage.

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 front-loaded and free of waste. But for a tool with no annotations and 0% schema coverage, this level of brevity is under-specification rather than effective 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?

An output schema exists, so return values need not be explained. Still, with no annotations, no parameter documentation, and only a vague temporal qualifier, an agent lacks enough information to invoke this tool confidently or distinguish it from its many retrieval 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 0%, so the description must compensate. It only gestures at 'as_of' via 'specific point in time' and says nothing about the expected format of that timestamp or what the required 'query' parameter accepts (natural language, fact ID, filter expression?). Both parameters are left semantically undefined.

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 ('Query') and resource ('facts') with a temporal qualifier ('valid at a specific point in time'), so the core purpose is inferable. However, it never explains what a 'fact' is in the Erinys domain or how this differs from siblings like erinys_recall, erinys_search, or erinys_get, leaving ambiguity about which tool an agent should pick.

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

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

There is no guidance on when to use this tool versus the many retrieval siblings (erinys_recall, erinys_context, erinys_search, erinys_get). No prerequisites, no exclusions, and no indication of when a point-in-time query is preferable to a current-state query.

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 and discloses nothing: not whether traversal is read-only (implied but unstated), how cycles or large graphs are handled, whether max_depth bounds cost, or whether relation_filter narrows traversal. An output schema exists, so return shape needn't be described, but the operational behavior is entirely absent.

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 with zero padding, which is structurally sound. But brevity here shades into under-specification rather than economy — the one sentence could have carried the parameter and routing information the agent needs at no structural cost.

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 graph-traversal tool with three unannotated, undescribed parameters and many overlapping siblings, the definition is not complete enough to invoke confidently. The output schema covers return values, but input semantics, depth behavior, and alternative selection are all 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 description coverage is 0% across three parameters. The phrase 'from a starting observation' weakly implies start_id, but max_depth (default 2) and relation_filter (default null) — the parameters that most affect behavior and result size — are never mentioned, and no accepted relation names or depth semantics are given.

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 verb and resource ('traverse graph') with an entry point ('from a starting observation'), so the basic action is clear. However, it never distinguishes this from sibling tools like erinys_lineage, erinys_search, or erinys_context, which plausibly also walk relationships, leaving the agent to guess which one to pick.

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

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

There is no guidance on when to use this versus alternatives, no preconditions, and no exclusions. The 27-sibling namespace makes this a real cost — an agent has no signal to route between traverse, lineage, search, and context.

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

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

No annotations are supplied, so the description carries the full burden. It does disclose genuinely useful PATCH semantics ('only provided fields are changed'), but omits whether null means 'clear the field' or 'leave unchanged', whether the id must exist, and what errors/permissions apply to a mutation.

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

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

Two short sentences, front-loaded with the action and followed by the key behavioral qualifier; nothing is padded. It is efficiently written but arguably too terse for a 7-parameter mutation.

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?

A return-value description is unnecessary since an output schema exists, which lowers the bar. However, for a mutation tool with no annotations and zero parameter documentation, the description leaves too many gaps — field-clearing semantics, failure modes, and sibling routing — to be considered complete.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate and largely does not. Beyond implying that id identifies the target and all other fields are optional, it says nothing about type, scope, metadata (merge vs replace), or the null-handling ambiguity baked into the schema defaults.

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 ('Update') and resource ('an existing observation'), and adds that this is a partial update. It never distinguishes itself from siblings like erinys_supersede (replacement) or erinys_reinforce, so an agent cannot tell which mutation tool applies without comparing 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?

There is no statement of when to use this versus erinys_save (create), erinys_supersede (replace), or erinys_forget. The only contextual hint is that a record must already exist, which is implied by 'existing' rather than stated as a precondition.

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