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

With no annotations, the description carries the full burden. It discloses the scan mechanism (static scan following import/export), that the closure is included, and that verdict is 'clean' only if nothing is found and the check passes, but it says nothing about read-only vs. side effects, the cost/timeout behavior of typecheck, or what happens on 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?

Content is front-loaded into one dense sentence about the audit scope, followed by a short verdict clarification. It is efficient and wastes little, though the opening sentence is long and packs several distinct behaviors together.

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 needn't be re-explained, and the verdict semantics are a useful addition. However, for a 3-parameter tool with no annotations and zero schema coverage, the missing timeout semantics and absence of any safety/behavior profile leave 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% for 3 parameters. The description meaningfully explains `typecheck` beyond the bare boolean (it triggers a batch check reporting assumed axioms) and treats `file` implicitly, but `timeout` is never mentioned anywhere, leaving one parameter 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?

The description names a specific verb (audit) and resource (a file) and spells out the exact scope: explicit `axiom` commands, holes, and the whole import closure via a static scan. It is concrete enough to separate it from narya_holes or narya_check_file, but it never names or contrasts those siblings explicitly.

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 conveys when the extra typecheck path applies (`if typecheck=True`) and what the verdict means, so usage is implied, but there is no explicit 'use this instead of X when...' guidance or statement of preconditions such as needing a started 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 behavioral burden and does so well: it discloses session reuse ('an open one is reused, otherwise one is started and kept, so later checks are fast'), that snippet definitions are undone afterwards, that the no-file mode requires its own imports relative to `directory`, and that holes fail in that mode. These are exactly the non-obvious traits an agent needs.

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 front-loaded with the core purpose, then two clearly demarcated conditional paragraphs. The density is reasonable for the complexity, though the two long parenthetical clauses in the first paragraph make it slightly heavier than necessary.

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 no explanation, and mutation/session side effects are covered. The description is nearly complete for a 4-parameter tool; only the `timeout` parameter and sibling differentiation against narya_check_file are 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%, so the description must compensate, and it explains `file`, `source` and `directory` (imports relative to it) with real semantics. It never mentions the `timeout` parameter, one of the four, which is the only 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 opening sentence gives a specific verb (typecheck) and resource (snippet of Narya commands) and even names typical command kinds. It is clear on its own, but it never distinguishes itself from the near-identically named sibling narya_check_file, leaving the agent to infer that this one takes an inline snippet while that one targets a file.

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 splits usage into two explicit modes ('With `file`' vs 'Without `file`') and says which context each applies to, including a concrete use case ('the way to try out a lemma next to the code that needs it'). It lacks any explicit routing to alternatives such as narya_check_file or narya_try, so it stops short of full when-to-use guidance.

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

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

No annotations are provided, so the description carries the full burden and does so: costs (slow, every import reloaded), failure semantics (stops at the first error; errors carry file/line/column), result semantics (ok/clean/errors/warnings/axioms/holes/timing), and a non-obvious fallback (compiled-import anomaly triggers automatic source recheck). That is well beyond what the schema conveys.

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 and the key cost warning, and every sentence carries information. Minor redundancy: 'slow' and the source_only recheck are each stated twice, which slightly dilutes an otherwise dense paragraph.

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 enumerating return fields is optional courtesy rather than necessity, and the error/hole/axiom semantics plus the stop-at-first-error rule make the tool's behavior predictable. The only real hole is the undocumented timeout parameter, which leaves one calling decision unguided.

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 fully explains source_only's behavior and its cost trade-off, and 'file' is self-evident from the typecheck framing, but the timeout parameter is never mentioned anywhere — an agent has no idea what it bounds or in what units.

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 ('Typecheck a .ny file') plus the distinguishing scope ('fresh Narya run', 'authoritative check'). It also contrasts itself with the session workflow (narya_start + narya_sync), so an agent can pick it apart from siblings without opening a 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?

Explicitly says when to use it ('final verdict') and names the alternative workflow for iteration ('keep a session instead: narya_start once, then edit the file and call narya_sync'). Exclusions and conditions are spelled out rather than inferred.

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 stopping the Narya process, but omits whether session data is removed, whether the action is reversible, what permissions are required, and how errors are handled.

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 sized for the action, though its extreme brevity does limit helpfulness.

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

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

Given no annotations, 0% parameter coverage, and no output schema explanation provided in the description, the definition is incomplete. It lacks usage context, behavioral details, and parameter semantics needed for an agent to confidently invoke it.

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, and the schema description coverage is 0%. The description never mentions the parameter or explains how to obtain a session_id, so it does not 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 description states a specific verb ('Close') and resource ('a session'), and adds that it stops the Narya process. It implicitly distinguishes from siblings like narya_start, but does not name any alternative tool explicitly.

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

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

No guidance is given about when to use this tool versus alternatives like narya_sessions or narya_start. The description only states what the tool does, leaving usage context to inference.

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

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

With no annotations, the description carries the full behavioral burden and does reasonably well: it discloses sequential fail-fast execution, that output/messages/new holes are returned, and the key side effect that definitions are ephemeral and undone by narya_sync retracting past them. It omits timeout behavior, session prerequisites, and what happens to already-applied commands on 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?

Three sentences, front-loaded with the core action and execution semantics, then side effects. No filler sentences, though the return-value sentence is mildly redundant given an output schema exists.

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 handles the main execution model, but for a multi-command execution tool with zero parameter documentation there are gaps: timeout semantics, session lifecycle requirements, and failure-state behavior are unstated.

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 adds real meaning to the commands parameter by enumerating valid command kinds, and 'in a session' implies session_id. But the timeout parameter is never mentioned anywhere, leaving a genuine gap.

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

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

The description states a specific verb (run) and resource (Narya commands in a session), and enumerates the command types (def, axiom, echo, synth, notation, import, show, undo). It also distinguishes itself from narya_sync by noting that definitions made here are not written to the file. Sibling differentiation is only partial, since it does not contrast with narya_try or narya_synth.

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 conveys the execution model (commands run one after another, stopping at the first failure) and the relationship to narya_sync, which implies usage. However, it never states when to choose narya_exec over siblings like narya_try, narya_check, or narya_synth, so the routing guidance is inferred rather than explicit.

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

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

With no annotations, the description carries the full behavioral burden. It describes what information is returned but does not state whether the tool is read-only, requires authentication, has side effects, or how the optional file parameter affects behavior beyond selecting a configuration.

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

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

The description is a single, front-loaded sentence that immediately identifies the tool as a toolchain check and lists the relevant outputs. There is no filler or repetition.

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

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

An output schema exists, so return values need not be fully explained, yet the description still lists them. However, it omits usage guidance and behavioral traits such as safety or permissions, leaving gaps for an agent deciding when and how to invoke it.

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 the single file parameter. It adds meaning by saying the configuration applies to 'file' or the default project, implying null/absence selects the default, but it does not specify expected file format, path semantics, or constraints.

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

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

The description clearly states this is a toolchain health check and enumerates what it inspects: project configuration, run method, version, and live session memory. It does not explicitly differentiate itself from siblings like narya_check or narya_audit, so it falls short of a 5.

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

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

There is no explicit guidance on when to call this tool versus alternatives. The phrase 'Toolchain check' implies a diagnostic context, but no conditions, prerequisites, or sibling alternatives are named.

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

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

With no annotations, the description carries the full burden, and 'List' does imply a read-only, non-mutating operation, which is the key trait an agent needs. It also notes that file position is reported only 'when known', a small but real behavioral caveat. However, it says nothing about permissions, ordering, or whether the session must be open, leaving gaps for an annotation-free 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 front-loaded sentence with the resource named first and the returned fields enumerated compactly after a colon. There is no filler or redundancy.

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

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

The tool has one parameter, an output schema, and low structural complexity, so the description does not need to explain return values in depth. It still manages to state the resource and the shape of the result, leaving only the relationship to sibling checking tools 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% for the single session_id parameter. The description's 'of a session' does convey that the argument selects which session's holes are listed, which is more than the bare schema offers, but it adds no format, sourcing (e.g., from narya_start/narya_sessions), or validity constraints.

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 ('List the open holes of a session') and even enumerates the fields returned. It is far more precise than a tautology, but it never distinguishes itself from plausibly overlapping siblings such as narya_check or narya_check_file, which could also surface unsolved goals.

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 when-to-use guidance, no prerequisites (e.g., a live session must exist), and no reference to an alternative tool. The phrase 'of a session' faintly implies usage after a session is established, but nothing is stated explicitly.

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 usefully discloses that the result includes location, comment, annotations, and 'all files that define the name' (a potentially multi-file result set), but says nothing about permissions, read-only nature, or how duplicates/ambiguity are handled.

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 dense, front-loaded sentence with no filler; the key constraint ('by exact name') and the payload contents come through immediately. Slightly awkward parenthetical nesting keeps it from a 5.

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

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

An output schema exists, so return shape need not be spelled out. However, with zero schema coverage on two parameters, the description leaves the role of 'file' undefined, which an agent needs in order to call the tool correctly.

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

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

Schema description coverage is 0% and neither parameter has a description. The description clarifies the semantics of 'name' (exact match), which is genuine added value, but the 'file' parameter is entirely unexplained in both schema and description.

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 ('full source of a declaration') and a precise selection mode ('by exact name'), which distinguishes it from the search-style sibling narya_search. It does not explicitly name that sibling, so it stops short of a 5.

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

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

The phrase 'by exact name' implies this is the tool for when you already know the identifier, contrasting with a search tool, but no alternative is named and no when-not condition is given. Usage is inferable 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?

With no annotations, the description carries the full burden and does meaningful work: it discloses what the index covers (names, signatures, the comment above each declaration, annotation files), the scoping behavior of file/line, the session-scoped hole behavior, and that exact-name matches are ranked first. It omits auth/rate-limit and result-ordering details, but for a read-only search this is solid disclosure.

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

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

Purpose is front-loaded in the first clause, followed by query-format guidance, index coverage, and scoping rules in a logical order. Every sentence conveys a distinct, actionable fact with no padding.

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 seven-parameter, zero-annotation search tool, the description covers purpose, query grammar, index scope, and the file/session/hole modes, and an output schema exists so return values need not be explained. Only the limit parameter is left uncovered, a minor omission.

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 for six of seven parameters: query formats (natural words, identifier fragments, book labels, exact names), file/line importability scoping, session_id+hole semantics, and kind values (def, axiom, data, codata, record). The limit parameter (default 10) is never mentioned, leaving one gap.

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

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

The description opens with a specific verb+resource: 'Find declarations (lemmas, definitions, types) by name, words or meaning,' and adds that Narya has no native search, clarifying this is a synthetic search layer. It does not, however, differentiate itself from the sibling narya_lookup, which plausibly overlaps.

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 clear conditional guidance: 'With file (and optionally line), only declarations importable there are returned' and 'With session_id and hole, the constants in the hole's type are added.' This tells the agent which parameter combinations trigger which scope, but no explicit when-not or named alternative is offered.

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 does disclose the content of each returned record (file, load progress, idle time, changed flag), which implies a safe read-only listing, but it never states whether it is read-only, whether it reflects a snapshot in time, or anything about cost/latency.

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; the resource comes first and the parenthetical field list is compact. Every clause earns its place.

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

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

With an output schema present, the return values need not be explained, and there are no parameters to document, so the definition is nearly sufficient. The remaining gap is the total absence of usage context — when a live-session listing is the right call versus sibling 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?

The tool takes zero parameters, so per the rubric the baseline is 4. The schema is fully self-contained (additionalProperties false, no fields), and there is nothing the description needs to compensate for.

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 ("List") and resource ("live sessions"), then enumerates the fields it reports (file, load progress, idle time, changed-since flag). The purpose is unambiguous, but it offers no differentiation from siblings like narya_health or narya_audit, which could plausibly also report session-ish state.

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

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

There is no statement of when to call this tool, no prerequisites, and no mention of alternatives among the many narya_* siblings. The agent must infer usage purely from the word "List".

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

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

With no annotations provided, the description carries the full burden and does well: it discloses that the action cannot be undone in Narya, that the file itself is not modified, that the result includes an edit locating the hole, and that new holes may be returned. It omits details such as timeout behavior and session-scoping requirements, so it is strong but not exhaustive.

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 front-loaded with the primary action and then layers in important constraints and workflow details. Every sentence carries useful information, though some phrasing is dense.

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

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

An output schema exists, so return values do not need full explanation, but the description still usefully summarizes the important `edit` result and next-step sync requirement. It is nearly complete for the operation, with only `session_id` and `timeout` semantics left implicit.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the core semantics of `hole` and `term`, including that the term may introduce new `?` holes, but leaves `session_id` and `timeout` 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 states a specific verb and resource: filling a named hole with a term, checked in the hole's context. It is clearly distinct from sibling operations like check or try, but it does not explicitly name or differentiate itself from alternatives such as narya_try or narya_synth.

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 the workflow instructions: apply the returned edit and re-sync the session when needed. However, there is no explicit guidance on when to use narya_solve versus narya_try, narya_synth, or other hole-related 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 behavioral burden. It does disclose the key trait that the operation is exploratory and non-committing ('without committing it'), which is valuable, but it says nothing about session requirements, side effects on the proof state, timeout behavior, 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?

Two sentences, front-loaded with the core purpose followed by the mode-specific behaviors. Tight and readable, with no filler, though it is dense with domain jargon that a non-Narya agent may find opaque.

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. However, with 0% schema coverage and no annotations, the definition omits the meaning of session_id and hole, any state/permission implications, and error behavior for an interactive proof tool.

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

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

Schema description coverage is 0% across 4 parameters. The description thoroughly explains `term` (single or comma-separated, datatype branching), but leaves `hole`, `session_id`, and `timeout` completely undocumented, so most parameters still have no semantics 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?

The description states a specific verb and object ('ask Narya for the shape of a solution of a hole without committing it') and spells out the two operating modes. It is clear, but it never names or contrasts a sibling such as narya_solve or narya_try, so the agent must infer which of the many narya_* tools 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?

It explains the two mode triggers ('Without term' vs 'With term'), which is useful context for parameter choice, but it gives no guidance on when to choose this tool over narya_solve, narya_try, or narya_synth. Usage is implied through the mode description 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?

With no annotations, the description carries the full burden and does so well: it discloses error behavior (stops at first error via error_at/messages), latency (first heavy import is slow, subsequent commands fast), and an automatic fallback (source_only used when compiled imports trigger an anomaly). It also states the return payload.

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 core action and return values in the first sentence, then adds per-mode behavior. The single dense paragraph is information-rich, though its length and multi-clause sentences slightly reduce scannability.

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 restated, yet the description explains them anyway and covers load semantics, import fallback, and error stops. It omits any mention of the session lifecycle/cleanup implied by the narya_close sibling and the timeout parameter.

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 covers five of six parameters meaningfully: file, line, imports (with path semantics relative to `directory` or the file's directory), directory, and source_only. The `timeout` parameter is never explained, leaving one 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?

States a specific verb ("Start") and resource ("an interactive session (a live Narya process)") and names what it returns (session_id, open holes). It hints at its role relative to narya_exec/narya_synth but never explicitly contrasts itself with the many sibling check/audit/session tools, so an agent must infer the boundary.

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 concrete condition-based guidance: with `file` it loads command-by-command to `line`; with `imports` it imports first; without a file it yields a scratch session for narya_exec / narya_synth. That names alternatives and the conditions that select them, but offers no explicit "when not to use this" or comparison against narya_try / narya_check.

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 notably well: it discloses that commands are retracted from the first changed one onward, that the file is replayed up to `line`, that unchanged commands and imports are preserved, and that passing an earlier `line` moves the session backwards. It omits error/permission behavior and says nothing about `timeout`.

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 and then the mechanics; every clause carries operational meaning. The sentences are dense and jargon-laden (Narya `undo`), which costs a little readability but not enough to call it bloated.

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 no prose, and the mutation semantics are covered. What is missing is the undocumented `timeout` parameter and any indication of failure modes, which for a state-altering replay tool is a real gap.

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

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

Schema description coverage is 0%, so the description must compensate. It explains `line` (default = whole file, earlier values move the session backwards) well, and `session_id` is inferable from context, but `timeout` is never mentioned, leaving one of three parameters wholly 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?

The description names a specific verb and resource ('Re-read the session's file after edits'), then details the retract/replay mechanics and the default scope of `line`. It is clearly distinguishable from a plain checker like narya_check_file, though it never names a sibling to route against.

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?

'After edits' implies the trigger condition, and the default (`line` defaults to the whole file) is called out, which is useful. However there is no explicit when-not guidance and no comparison to adjacent siblings such as narya_check_file or narya_try.

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

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

With no annotations, the description must carry the full behavioral burden. It does disclose two important traits — 'Nothing is committed' (side-effect free) and that only terms that support synthesis work while 'a bare abstraction does not' (a failure-mode hint). It says nothing about session lifecycle, timeout behavior, or error semantics.

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

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

Three compact sentences, front-loaded with the core action and the normalize variant, with the restriction stated last. The heavy backtick/Narya-terminology inline markup adds slight reading friction 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?

An output schema exists, so return values need not be described. For a 5-parameter tool the description covers the non-obvious semantics (normalize, hole, non-commitment, valid term forms) well; the remaining silhouette — timeout and session_id — is standard across this tool family.

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 5 parameters, so the description has to compensate. It usefully explains `normalize`'s dual behavior and `hole`'s scoping effect, but leaves `session_id` and `timeout` completely unexplained, so compensation is only partial.

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 — 'Synthesize the type of `term`' — and pins it to the underlying Narya `synth` operation, so an agent knows exactly what the call produces. It stops short of differentiating itself from siblings like narya_check, narya_try, or narya_solve, which also operate on terms.

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 two concrete usage conditions: use `hole` to elaborate in a hole's context, and use `normalize=True` to also normalize (the `echo` path). However, there is no guidance on when to prefer this over narya_check or narya_try, and no stated prerequisites such as needing a live 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 and it does disclose the key behavioral trait: the tool is static and does not run Narya, so it has no evaluation side effects. It does not address permissions, file-resolution behavior, or failure modes for a non-.ny input, but the critical safety/behavioral fact is 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?

Two tight sentences with the content summary front-loaded and the static/no-execution caveat last. 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?

An output schema exists, so return structure need not be explained, and the description still summarizes the payload plus the holes information. What remains thin is parameter guidance (what a valid 'file' value is), which is the only real gap for this simple one-parameter tool.

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

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

Schema coverage is 0% and the single 'file' parameter has no description in the schema. The description only implies it is a '.ny file', adding marginal meaning (source file path) without clarifying path resolution or format constraints.

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 (outline) and resource (.ny file), then enumerates what the outline contains (commands, names, line ranges, holes). The closing clause 'Static; does not run Narya' separates it from execution-oriented siblings such as narya_exec and narya_try.

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 'Static; does not run Narya' clause gives a clear when-to-use signal (structural inspection without evaluation) and implicitly a when-not (use an execution/check tool if you need evaluation). It does not, however, name a specific alternative sibling to route to.

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 disclose key traits: it does not commit ('without solving it'), caps input at 20 candidates, and describes the result shape (per-candidate typecheck results with errors, plus the first success). It does not cover the timeout behavior, side effects, or whether candidates are evaluated sequentially.

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, front-loaded with the what and the non-committal constraint, then the return shape, then the follow-up action. 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?

An output schema exists, so return values need not be spelled out, yet the description adds a useful summary anyway. For a 4-param tool with no annotations, two undocumented parameters (session_id, timeout) and no note on session prerequisites leave a modest gap.

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

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

Schema description coverage is 0%, so the description must compensate. It adds real meaning for 'terms' (up to 20 candidates that are typechecked) and 'hole' (typed in its context), but 'session_id' and 'timeout' are never mentioned and neither param has format or indexing details.

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

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

States a specific verb and resource: check candidate terms against a hole's type in its context, and explicitly says it does not solve the hole. That contrasts it with narya_solve, but it leaves potential overlap with other checking siblings (narya_check, narya_synth) unaddressed.

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 a clear workflow rule: probe candidates here without committing, then 'Commit with narya_solve.' The alternative and the condition for switching to it are stated. No explicit when-not-to-use or prerequisites (session must exist, hole must be valid) are given.

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