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 'server mutation policy' is never explained: it does not say whether proof search mutates the module state, what the default policy is, or what happens on failure. Async, timeout, and deferral behavior are only visible in the schema, not in the description.

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

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

It is a single front-loaded sentence with no wasted words. However, the compression leaves key terms like 'server mutation policy' undefined, making it concise at the cost of clarity.

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, goal-mutating proof-search tool with no annotations and no output schema, the description is far too thin. It never explains the mutation policy, the async/job-handle behavior, or default versus overridden settings, leaving the agent to infer critical behavior from parameter names 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 100%, so all seven parameters including goal, apply, async, query, timeoutMs, includeRaw, and deferAfterMs are already documented in the schema. The description's mention that 'apply overrides it' merely restates the schema and adds no new syntax or format detail, so the baseline of 3 applies.

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

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

States a specific verb and resource: 'Run Agda proof search'. It is distinguishable from siblings like agda_refine and agda_case_split by the proof-search framing, though the trailing clause 'apply overrides it' is oblique and does not clarify how it differs from other goal-mutating tools.

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

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

There is no guidance on when to choose this over agda_refine or agda_case_split, nor on prerequisites such as having a valid goal handle from the latest module state. The only routing hint is the cryptic 'using the server mutation policy; apply overrides it', which does not tell the agent when to invoke the tool.

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 must carry the full behavioral burden. It hints at a server mutation policy and an override via apply, but does not explain what gets mutated, whether preview is the default, or what side effects to expect.

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

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

The description is short and front-loads "Case split," but the semicolon clause about server mutation policy is ambiguous and weakly structured. It is concise but not as clear or informative as a well-structured definition would be.

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 seven parameters and no annotations or output schema, so the description should do more to explain the operation and its behavioral implications. Instead, it is too sparse to fully orient an agent beyond what the parameter schema already says.

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

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

Schema description coverage is 100%, so the input schema already documents all seven parameters thoroughly. The description adds no parameter-specific details beyond the schema, making the baseline score of 3 appropriate.

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

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

The phrase "Case split" identifies the operation, but it lacks an explicit object such as the Agda goal being split and does not distinguish this tool from siblings like agda_refine or agda_auto. The remainder of the description focuses on server mutation policy rather than clarifying the tool's purpose.

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

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

The description gives no guidance about when to use this tool, when not to use it, or which sibling tool is the alternative. Mentioning that "apply overrides that policy" describes a parameter behavior, not a usage condition.

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 not disclose whether inference is read-only, how async/job handles work, what timeout or defer behavior means, whether raw logs are returned, or what rewrite modes do.

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 concise, though its brevity leaves important details unstated for a complex 8-parameter 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?

Given 8 parameters, no annotations, no output schema, and only 50% schema coverage, the description is not complete enough. It omits async/job behavior, rewrite options, timeout/raw-log controls, and the read-only nature of type 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?

There are 8 parameters with only 50% schema description coverage. The description clarifies that workspace and goal determine scope and names expression, but it omits the rewrite enum, async job behavior, timeoutMs, includeRaw, and deferAfterMs semantics.

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: infer the type of an expression. It also names the scope, workspace or goal-local, which helps distinguish the context. However, it does not differentiate from siblings such as agda_typecheck or agda_normalize_expression.

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. It implies usage through the words "infer the type," but does not explain when to choose it over agda_typecheck, agda_normalize_expression, or other query tools.

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

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

With no annotations, the description carries the full burden and does disclose the two behaviors that matter: the call blocks for up to waitMs, and it degrades to a pending result rather than failing when the job is still running. It omits error/failure-job behavior and any note on calling repeatedly on the same job id.

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 blocking behavior and the pending fallback are both stated compactly and 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?

There is no output schema, so the description should carry return-value semantics, and it only covers the pending case — what a completed result looks like (result shape, statuses, completed vs failed) is unstated. For a 2-param job-polling tool this is adequate but leaves a clear gap.

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

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

Schema description coverage is 100%, so both parameters are already fully documented in the schema and the description merely restates waitMs. It adds no format or edge-case hints (e.g. waitMs=0 meaning an immediate poll) beyond what the schema provides.

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

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

Clear verb+resource: 'Collect the result of a pending Agda job' tells an agent exactly what the call delivers. However, it does not distinguish itself from near siblings like agda_job_status or agda_job_await_any, which an agent could easily confuse with this blocking 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?

'waiting up to waitMs; returns pending again if still running' implies the blocking use case and the poll-loop pattern that follows from it. But it never states when to prefer this over agda_job_status (non-blocking check) or agda_job_await_any (wait on multiple jobs), leaving sibling selection to inference.

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

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

No annotations, so the description carries the behavioral burden; it does disclose the race semantics (returns on first completion rather than all), which is the key trait. However it says nothing about what is returned — the winning job id, its status, or what happens when the waitMs budget expires — leaving a meaningful 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?

A single semicolon-joined sentence with the semantics front-loaded and the usage hint second. No filler, no redundancy with the schema.

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

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

With no annotations and no output schema, the description should say what the caller receives on first completion versus on timeout. It conveys the trigger condition but not the result shape, so it is only partially complete for a tool whose return value matters most.

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

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

Schema description coverage is 100%, so both `jobs` (race set, omit to await all tracked) and `waitMs` (timeout before returning pending) are already fully documented. The description adds only the 'FIRST' framing and nothing about ordering or default waitMs behavior, so baseline 3 applies.

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

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

States a specific verb (wait) and resource (pending jobs) with the distinguishing scope 'FIRST of several', which separates it from a single-job await. It stops short of naming the sibling agda_job_await/agda_job_status, so the differentiation is implied rather than explicit.

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?

'use after fanning work out across workspaces' gives a clear usage context that tells the agent this is a post-fan-out aggregation call. There is no when-not guidance or explicit pointer to agda_job_await for single-job cases, which keeps it from a 5.

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 the key side effect (slot release) but leaves open permissions, behavior on already-completed/unknown jobs, and whether the job's results become unrecoverable.

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 the verb and resource, with zero filler. Every clause earns its place by adding the side-effect detail.

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

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

For a single-parameter cancel tool with full schema coverage and no output schema, the description covers purpose, scope, and effect sufficiently to invoke it correctly. Missing only edge-case behavior for non-pending jobs.

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

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

Schema coverage is 100% and the single 'job' parameter is already documented as 'Job id returned by a pending tool result'. The description adds nothing about the parameter, so the baseline 3 applies.

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

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

States a specific verb ('Abort') and resource ('a pending Agda job') and adds the concrete effect ('release its Agda command slot'). No sibling tool cancels jobs, and the description makes its distinct role obvious against agda_job_await / agda_job_status.

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

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

The word 'pending' implicitly scopes usage to not-yet-completed jobs, which is genuinely useful guidance. But it never says what to do instead (agda_job_status to check state, agda_job_await to wait) or how it behaves on non-pending jobs.

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 behavioral load, and it does disclose one meaningful trait: that finished/collected jobs are excluded from the result. It says nothing about ordering, whether job IDs are returned for reuse, or that it is a non-blocking read, which leaves the read semantics only partly covered.

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 scope qualifier placed immediately after the resource. Zero filler and nothing an agent must read past to find the point.

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 no-param, no-annotation, no-output-schema tool, the description should say roughly what each entry contains (at minimum that job IDs are returned so they can be fed to agda_job_status/await). That chaining detail is missing, so the definition is usable but incomplete for an agent orchestrating the job 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 schema declares zero parameters and 100% description coverage, so there is nothing for the description to disambiguate. The scope qualifier in the description is the only semantics available, and it is consistent with the 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?

The description states a specific verb ('List') and resource ('Agda jobs') and narrows scope to jobs that are 'still running or awaiting collection'. That scope filter implicitly separates it from agda_job_status (single-job lookup) and agda_job_await (blocking wait), though neither sibling is named 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?

Usage is only implied: an agent can infer this is how you enumerate in-flight jobs before calling agda_job_status, agda_job_await or agda_job_cancel, but the description never says when to prefer one of those siblings instead. No exclusions or prerequisites are stated.

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

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

No annotations are provided, so the description carries full disclosure burden. It does contribute one genuinely useful trait — the call is non-blocking and returns immediately rather than awaiting completion — but it says nothing about what states are reported (pending/done/failed), what happens with an invalid or expired job id, or whether the job remains pollable afterward.

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 non-blocking property front-loaded; nothing is wasted. It is terse to the point of omitting useful state/error detail, but there is no filler.

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

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

For a simple one-parameter read tool with full schema coverage and no output schema, the description is close to adequate, but it never states which states can be reported or how terminal states are surfaced, which is the main thing an agent needs before deciding to poll versus await.

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

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

Schema coverage is 100% and the single 'job' parameter is documented as 'Job id returned by a pending tool result,' so the schema fully carries parameter semantics. The description adds nothing beyond that, which is the expected baseline for a one-param tool.

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?

Specific verb ('Report the state') plus a specific resource ('a pending Agda job'), which clearly separates it from agda_job_await and agda_job_await_any, which block on the job. The differentiating clause 'without waiting for it' is implicit rather than naming siblings, so it falls just short of 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 'without waiting for it' hints that this is the non-blocking/polling alternative to agda_job_await, but no alternative is named and no explicit when-to-use or when-not-to-use guidance is given. Usage must be inferred from the contrast with sibling names.

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 discloses the disk-loading scope and the workspace allowlist constraint, but says nothing about blocking behavior, job handles, error/failure semantics, or what gets loaded into the Agda process state—gaps that matter for a tool with async and defer options.

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

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

A single dense sentence with the core action front-loaded and the conditional clause second. Zero wasted words.

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 an 8-parameter tool with no output schema and no annotations, the description is thin: it never mentions the job-handle model implied by async/deferAfterMs, nor result shape. The schema covers parameters, but the description leaves the overall operating model underspecified.

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

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

Schema description coverage is 100%, so every parameter is already documented in structured form; the description only echoes the workspaceRoot/--dynamic-workspaces condition. Baseline 3 is appropriate since the schema does the heavy lifting.

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 ('Load and typecheck one top-level Agda module from disk') with clear scope. However, it never distinguishes itself from the sibling tool agda_typecheck, so an agent cannot tell from the description alone 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?

The only usage guidance is conditional: pass workspaceRoot with --dynamic-workspaces to select a workspace. There is no statement of when to use this tool versus agda_typecheck or the job tools, so the primary routing decision 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, yet it says nothing about the async/job-handle model, blocking behavior, or timeouts that dominate the parameter set. The only behavioral hint is the vague scope distinction, which is far from sufficient for an 8-parameter 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?

It is a single front-loaded sentence with no filler, so it is concise. But it is concise by omission rather than by precision – the one sentence could easily carry the missing scope and behavior context without becoming 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?

For a tool with 8 parameters, an async job model, no annotations, and no output schema, the description is well short of what an agent needs to invoke it correctly. The scope distinction is the only real content and even that is under-explained.

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 only 50%, and the description explains only the workspace/goal scope split, adding no meaning for the four undocumented parameters. Notably the mode enum (ignore_abstract, head, use_show_instance) is left completely unexplained despite being central to how normalization behaves.

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

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

The description names a specific verb+resource (normalize an expression), which is clearer than a tautology. However, it never explains what 'normalize' produces in Agda terms (a normal form) and the phrase 'workspace or goal-local scope' is ambiguous, so an agent cannot confidently distinguish this from siblings like agda_infer_type or agda_auto.

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 tool versus alternatives. With siblings such as agda_infer_type, agda_refine, and agda_auto, the absence of any routing guidance leaves the agent to guess which tool applies to a given proof state.

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. 'Query' implies a read operation, but the description does not explain async/job behavior, whether the call blocks, what visible versus invisible metavariables means operationally, or what the response contains.

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 compact sentence with no wasted words and the core resource is front-loaded. It is perhaps too terse, but that is a completeness issue rather than a conciseness problem.

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

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

There are five parameters, no annotations, and no output schema, yet the description is only one sentence. It does not explain the job-handle/async model, return values, or how querying metavariables relates to the surrounding Agda workflow 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 100%, so all five parameters are already documented in the schema, including async, timeoutMs, workspace, includeRaw, and deferAfterMs. The description adds no parameter-specific meaning beyond the schema baseline.

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: 'Query ... metavariables'. It also narrows scope to visible and interaction-backend invisible metavariables, but does not explicitly distinguish this from sibling tools like agda_retrieve_goals or agda_retrieve_constraints.

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 says what the tool queries but gives no guidance on when to use it instead of alternatives such as agda_retrieve_goals or agda_retrieve_constraints. There are no exclusions, prerequisites, or contextual cues for tool selection.

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 hints that the operation is governed by a server mutation policy and can be overridden, but never states what is mutated, whether a preview is a dry run, or what a job handle implies — and the apply/override point is already spelled out in the schema.

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 short sentence with no padding, but the second clause duplicates what the schema already says about `apply`, so one of the two clauses does not earn its place. Being brief here reads as 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?

This is an 8-parameter mutating tool with no annotations and no output schema; the description should at least explain the refine operation, the preview-vs-apply default, and whether a job handle or inline result comes back. The rich schema covers parameters, but the core operation and mutation semantics remain unexplained.

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 88%, so nearly every parameter (goal, apply, async, expression, deferAfterMs, includeRaw) is already documented in the schema. The description adds nothing parameter-specific beyond repeating the apply override, so the baseline 3 applies.

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

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

"Refine using the server mutation policy" largely restates the tool name and adds a policy reference, but never says what is being refined (a goal hole / metavariable) or what refinement means in Agda terms. It gives no basis for distinguishing it from siblings like agda_auto, agda_case_split, or agda_infer_type.

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 only usage-adjacent statement is "apply overrides that policy," which describes a parameter rather than when to choose this tool. There is no mention of when to use refine versus auto, case_split, or infer_type, and no prerequisite such as requiring a loaded module or goal handle.

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 blocking versus job-handle behavior, timeouts, or error conditions even though the parameters (async, deferAfterMs, timeoutMs) reveal this is a potentially long-running, deferrable call. The only behavioral fact added is the 'active module' scope.

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 and no redundancy. It is efficient, though its brevity leaves the guidance gaps noted elsewhere.

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 async deferral, timeouts, and no annotations or output schema, the description never explains what a constraint result looks like or how the job-handle path behaves. It is too thin for the tool's operational complexity, even though the schema covers the parameters.

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

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

Schema description coverage is 100%, so every parameter (async, timeoutMs, workspace, includeRaw, deferAfterMs) is already documented in the schema, which sets the baseline at 3. The description adds only the notion of an 'active module' and no per-parameter meaning.

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

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

The description gives a specific verb ('Retrieve') and resource ('constraints') scoped to 'the active module in a workspace', so an agent can tell what it returns. It does not differentiate itself from close siblings such as agda_retrieve_goals or agda_retrieve_context, so it stops short of a 5.

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

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

There is no statement of when to use this rather than agda_retrieve_goals, agda_retrieve_context, or agda_query_metavariables, and no prerequisites or exclusions are given. The agent must infer the choice entirely from the tool name.

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 mention read-only behavior, async/job-handle semantics, blocking versus non-blocking behavior, timeout implications, or side effects, despite parameters like async, deferAfterMs, and includeRaw implying non-trivial execution behavior.

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

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

The description is a single front-loaded sentence with no filler or redundancy. It is efficiently sized and easy to scan, even though its brevity contributes to gaps captured in other dimensions.

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

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

This is a 6-parameter tool with no annotations and no output schema, yet the description omits return shape, async/job behavior, error semantics, and relationship to the plural sibling agda_retrieve_contexts. It gives the basic purpose but is not complete enough for confident invocation in non-trivial 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 description coverage is 83%, so the schema already documents most parameters, and this sets the baseline at 3. The description reinforces that the goal parameter is an opaque handle, but it adds no meaning for rewrite, async, timeoutMs, includeRaw, or deferAfterMs beyond what the schema provides.

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

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

The description states a specific verb and resource: retrieve the type and local context for a goal handle. It is clear what the tool returns, but it does not distinguish itself from the near-duplicate sibling agda_retrieve_contexts (plural) or from agda_retrieve_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, and no mention of alternatives. With a sibling named agda_retrieve_contexts, an agent has no description-based way to decide which context-retrieval tool 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 behavioral burden. It only discloses batching; it says nothing about the async/job-handle behavior, timeout and deferral semantics, what happens with invalid goal handles, or whether results are ordered per goal.

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 scope constraint is stated first and nothing is repeated.

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 6-parameter tool with no annotations and no output schema, one sentence is not enough. An agent still lacks the return shape (how contexts map to each goal handle), the async/defer contract, and how this relates to agda_retrieve_goals versus agda_retrieve_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 83%, so the schema already documents goals, async, timeoutMs, includeRaw, and deferAfterMs. The description adds only the batching context for goals and nothing for rewrite (which lacks a schema description) or the other parameters, so baseline 3 applies.

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

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

States a specific verb (retrieve) and resource (types and local contexts) scoped to 'several goal handles'. The 'several ... one round trip' framing implicitly distinguishes it from the singular sibling agda_retrieve_context, but never names that sibling 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 phrase 'in one round trip' implies this is the batch variant to use when multiple goals need contexts, which is useful implied guidance. However, there is no explicit when-to-use/when-not rule, no mention of the singular agda_retrieve_context alternative, and no preconditions such as needing loaded goals.

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

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

No annotations are provided, so the description bears the full disclosure burden. It says nothing about the tool's asynchronous nature, its blocking behavior, or that it can return a job handle instead of goals (flags that exist in the schema as async/deferAfterMs). For a tool in a job-handle-based workflow, that omission forces the agent to infer behavior from parameter names alone.

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 the object front-loaded, so nothing is wasted. But at eight words it crosses from concise into under-specified, and "opaque handles" adds ambiguity rather than 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?

This is a five-parameter tool with async/job-handle semantics, no annotations, and no output schema. The description does not explain what a "handle" is, that results may be deferred into a job, or what the returned goals look like — leaving the agent to reconstruct the interaction model from parameter names.

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

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

Schema description coverage is 100%, with every parameter documented in-schema (workspace handle provenance, async semantics, timeout override, includeRaw size caveat). The description adds nothing beyond the schema, so the baseline of 3 applies.

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

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

States a verb ("Retrieve") and an object ("current visible goals and opaque handles"), so the intent is roughly graspable. However, "opaque handles" is undefined jargon and there is no differentiation from closely related siblings such as agda_query_metavariables, agda_retrieve_constraints, or agda_retrieve_context. An agent cannot tell from this sentence which of those four it should call.

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 prerequisite (e.g., a loaded module), and no mention of alternatives. The only cue is implicit in "current visible goals", which assumes the reader already knows the Agda interaction model.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it omits important behavior. Most notably, the schema exposes async and deferAfterMs parameters, meaning this call can return a job handle and block or defer — none of that is mentioned. It also says nothing about cost, permissions, or whether the probe touches the filesystem/Agda binary.

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 front-loaded sentence listing the three reported items with zero filler. Nothing in it is redundant given the schema handles parameters.

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

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

With no output schema, the description does at least enumerate what gets reported (installation, compatibility, workspaces), which covers the return content at a high level. The main gap is the async/job-handle behavior implied by the parameters, which an agent would only discover from the schema.

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

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

Schema description coverage is 100%, so all four parameters (async, timeoutMs, includeRaw, deferAfterMs) are already documented in the schema with good detail. The description adds no parameter-level meaning beyond the resource list, so the baseline 3 applies.

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

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

The description uses a specific verb ('Report') with three concrete resources: detected Agda installation, compatibility, and active workspaces. This clearly separates it from the action-oriented siblings (load, typecheck, job_*), though it never explicitly contrasts itself with them.

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

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

Usage is only implied: an agent can infer this is a diagnostic/environment-inspection call, likely useful before typechecking or when workspace state is unknown. There is no explicit 'call this when…' statement, no prerequisites, and no mention of 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 behavioral burden, but it only states the core action. It omits important traits such as long-running execution, job-handle/blocking behavior, and what diagnostics or goals are returned.

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. The brevity is efficient, though it leaves gaps that are better scored under contextual completeness.

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

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

The description is incomplete for a typechecking tool with no output schema: it never explains what is returned (e.g., goals, diagnostics, job handle). Schema parameters cover inputs, but an agent cannot tell from the description what a successful result looks like.

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

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

Schema description coverage is 100%, so all seven parameters are documented in the schema. The description adds no parameter semantics beyond that baseline.

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 compound verb ('Reload and typecheck') and resource ('active module in a workspace'), so the core action is clear. It does not explicitly distinguish itself from sibling agda_load_module or say whether the module must already be loaded, so it stops short of full sibling differentiation.

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

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

No when-to-use or when-not-to-use guidance is provided, and no alternative sibling tools are named. The agent must infer that this is for re-checking an already-loaded module rather than initial loading.

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