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

Annotations already declare readOnly/idempotent/non-destructive/no-open-world, so the safety profile is covered. The description adds beyond that with 'Cost: free, no provider call', which is genuine cost/latency context an agent can act on. It is thin but real added value over structured fields.

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

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

Three short clauses, fully front-loaded: purpose first, then sequencing, then cost. Every sentence earns its place with no filler or repetition of the title.

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

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

An output schema exists, so return values need not be described, and annotations cover the safety profile. The remaining hole is the opaque `requests` payload, and the description does not compensate for the zero-coverage schema, so the definition is adequate but incomplete for a tool that consumes a batch.

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?

One parameter with 0% schema coverage and an unconstrained items schema (additionalProperties: true), so the schema describes essentially nothing about a request object. The description only says 'multi-request batch' and never explains what each element must contain, leaving the agent to guess the batch shape.

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

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

States specific verbs and resource: 'Plan, coalesce and price a multi-request batch.' The batch scope plus the named sibling ('Use before `arsenkin_batch_prepare`') separates it from the single-request `arsenkin_estimate`. It stops short of an explicit contrast with that non-batch sibling, so it lands at 4 rather than 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?

Gives a clear sequencing rule ('Use before `arsenkin_batch_prepare`') and a cost cue ('free, no provider call') that tells the agent to call this first. It never names when not to use it or what the alternative is if the batch is rejected, so it is clear context without exclusions.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false, and idempotentHint=false. The description adds genuinely useful context beyond that: it clarifies the write is limited to an 'approval record only, no spend' and calls the approval 'bounded', which tells the agent the side effect is scoped and non-monetary. It does not address retry/idempotency behavior, which is a minor remaining gap given the annotations already cover safety.

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 clauses, front-loaded with the effect and immediately followed by workflow position and side-effect scope. No filler sentences.

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 exists so return values need no explanation, and the workflow ordering is complete. However, the opaque 'requests' payload is a real gap for a batch tool, leaving the agent unable to construct a valid call from the description 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?

The single parameter 'requests' is an array of open objects with 0% schema description coverage, and the description says nothing about its shape or contents. With low coverage the description is expected to compensate, but it does not, so an agent cannot tell what to put in requests.

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

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

States a specific verb and resource ('Create one bounded approval for a batch') that clearly differs from siblings like arsenkin_prepare and arsenkin_batch_submit. The batch scope and approval artifact are 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?

Gives explicit sequencing: 'Use after arsenkin_batch_estimate; then arsenkin_batch_submit.' This routes the agent to the correct workflow position and names both adjacent tools, leaving nothing 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?

Annotations already declare destructive/openWorld/idempotent, so the bar is lower, yet the description adds real value: it discloses the cost profile ('spends Arsenkin limits'), the approval gate, and the coalescing/polling async behavior. It does not say what the queued job destroys or how failures surface.

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?

Compact and front-loaded: the primary action leads, then the workflow, then cost/prereqs. Semicolon-separated clauses are dense but each carries distinct information, with 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 an async, destructive, paid batch submission with an output schema available, the description covers the essentials: approval prerequisite, cost, next-step polling, and upstream tool. The uncovered gap is the contents of the requests payload.

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 carry the load. It explains where approval_id comes from ('from arsenkin_prepare'), which is genuinely useful, but says nothing about the shape of the requests array or the role of idempotency_key beyond what idempotentHint implies. Partial compensation only.

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 ('Queue an approved batch job') and the async execution model ('the worker coalesces and polls'). It implicitly contrasts with the single-job sibling arsenkin_submit via 'batch', but never names that alternative explicitly, so an agent must infer the distinction.

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 precondition ('Use after explicit OK') and a concrete next step ('poll arsenkin_task_status'), plus the upstream dependency on arsenkin_prepare. It stops short of naming when NOT to use this versus arsenkin_submit, so there is no explicit exclusion 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?

Annotations already declare destructive, non-read-only, idempotent behavior, so the bar is lower. The description still adds genuine behavioral context beyond them: "Request cancellation" signals it is a request rather than an immediate guaranteed kill, and "already spent limits may not return" discloses a real cost consequence of the destructive action.

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

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

Two short sentences, zero filler, with the action and its scope front-loaded and the caveat following. 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?

An output schema exists, so return values need not be described, and annotations carry the safety profile. The description covers trigger, scope, and side-effect caveat, leaving only the origin/format of job_id unaddressed.

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

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

Schema description coverage is 0% and the description does nothing to compensate: job_id is never explained, nor how it is obtained (e.g. from prepare/submit). With one undocumented parameter, the description leaves the only input's semantics entirely to inference.

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?

"Request cancellation of your queued/running job" names a specific verb (cancel) and resource (job), and scopes it to queued/running jobs. It is unambiguous against siblings like submit/status/get_result, though it doesn't explicitly name an alternative it could be confused with.

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 when the user aborts" gives a clear triggering condition for invocation. It stops short of stating when NOT to use it or pointing to a sibling (e.g. status/limits) for checking state first, so it's clear context without full exclusions.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered; the description adds genuinely new behavioral context — that it never performs an install and that results are served from a 24h cache, which tells the agent results may be stale and explains why a force refresh might exist. Cost is also disclosed. It stops short of describing the return payload, which the output schema covers.

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 clauses, front-loaded with the action and scope, and every clause carries distinct information (action, non-mutation, cost/caching). Zero 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 explained, and the description covers action, safety boundary, cost, and cache freshness. The only real gap is that the lone input parameter is left undocumented.

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

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

Schema description coverage is 0% and the single parameter (force_refresh) is never mentioned in the description, so the agent must infer its meaning from the schema alone. The '24h cache' note is the only indirect hint that a refresh override exists.

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 for a newer server release') and immediately bounds the scope with 'never installs', so an agent knows this is a read-only update check rather than any prepare/submit-style sibling. No other sibling covers this action, and the purpose is unambiguous in one clause.

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 'never installs' clause implies the boundary between checking and acting, and 'Cost: free' hints at when it is cheap to call, but no alternative tool or explicit when-not condition is named. 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?

Annotations already cover safety (readOnly, idempotent, non-destructive), but the description adds genuinely new behavioral context: the call is free and makes no provider call, which tells the agent there is no billing or external side effect. It stops short of describing validation failure behavior or what a rejected payload looks like.

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 tight clauses with zero filler, and the core action is front-loaded ahead of the ordering and routing guidance. Every sentence earns its place.

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

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

An output schema exists, so return-value explanation is not required, and the description covers workflow ordering and cost. However, with 0% parameter coverage and a free-form nested payload object, an agent still lacks the domain framing (what a profile/payload must contain) needed to invoke it correctly on the first try.

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 schema itself is bare: 'profile' is an undescribed string and 'payload' is an open object with additionalProperties. The description does not explain what a profile is, what fields a payload requires, or how validation errors are reported, so it fails to compensate for the coverage gap on a nested-object parameter.

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

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

States a specific verb pair (validate, estimate) and an explicit scope of 'one job payload', which cleanly separates it from the batch variant. An agent can identify the operation and its counterpart without opening either schema.

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

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

Names the preceding tool in the workflow ('Use before arsenkin_prepare') and explicitly routes multi-payload callers to arsenkin_batch_estimate. This is a textbook when-to-use plus alternative-routing statement.

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?

Annotations already declare readOnly/idempotent/non-destructive/openWorld=false, so the safety profile is covered. The description adds genuinely non-structured behavior: the export is bounded, carries provenance, is free, and makes no provider call. It stops short of saying what happens for a missing/unsaved job or what the bounds do on overflow.

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 tight sentences: purpose first, the usage cue second, cost/behavior third. No repetition of the schema or annotations, and each sentence carries distinct information.

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

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

An output schema exists, so return-format explanation is rightly omitted. With zero schema descriptions on three parameters, though, the description should have covered job_id expectations and the format enum; the cost/behavioral note is good but the parameter story is incomplete.

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 carries the param burden. It clarifies format (JSONL/CSV) and that output is bounded (implying max_rows), but never enumerates the accepted format values or explains max_rows default/limits, and job_id semantics are untouched.

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 (export) plus resource (a saved job's result) and the output formats it produces (bounded JSONL/CSV), which is enough to read it apart from get_result/result_table. It does not name the sibling it is exclusive of, so the distinction is implied rather than stated.

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

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

"Use for spreadsheets/files" is a real conditional hint pointing at downstream file consumption, and the cost note implies when it is cheap to call. However, it never contrasts with the obvious alternatives (arsenkin_get_result, arsenkin_result_table), leaving the agent to infer why it would export instead of reading the result table.

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?

Annotations already declare readOnlyHint/idempotent/non-destructive, so the bar is lower. The description still adds real value with the size warning ('can be large') and the cost disclosure ('Cost: free'), neither of which appears in structured fields. It does not mention potential truncation or pagination for large results, which keeps it from a 5.

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

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

Three short clauses: what it does, the size caveat, the sibling routing, and cost. Front-loaded purpose, zero filler, every sentence earns its place.

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

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

An output schema exists, so return structure need not be described. Given the remaining gaps are only job_id provenance, the description covers routing, size expectations, and cost — enough for an agent to invoke 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?

Single required `job_id` with 0% schema description coverage, so the schema adds no meaning. The phrase 'your job' weakly implies job_id comes from a prior submit call, but the description never states the identifier's origin, format, or where to obtain it. Baseline adequacy rather than genuine added 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?

States a specific verb and resource ('Return the stored result of your job') and explicitly distinguishes itself from two siblings, `arsenkin_result_table` and `arsenkin_export_result`. An agent can tell exactly which result-retrieval tool to pick 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?

Gives explicit routing rules: use this for small jobs, `arsenkin_result_table` for compact tables, `arsenkin_export_result` for files. This is when-to-use plus named alternatives, not 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?

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and openWorld, so the safety profile is covered. The description adds a non-obvious behavioral trait not in annotations — "Cost: free" — which matters when an agent is deciding whether to spend a call. It doesn't mention rate limits or auth needs, but those are minor here.

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

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

Three short, front-loaded sentences: purpose, then usage timing, then cost. Nothing is redundant and each sentence carries distinct information.

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

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

An output schema exists so return values need no explanation, annotations cover the safety/behavior profile, and the description adds usage timing and cost. For a zero-parameter read tool this is complete.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. The description adds no parameter detail, but none is needed given the empty schema with additionalProperties: false.

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 (Read) and resource (total and spent Arsenkin limits), making it clear this is a quota/usage inspection tool. It doesn't explicitly contrast itself with sibling tools like arsenkin_status or arsenkin_estimate, but the resource name is distinctive enough to avoid confusion.

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 before prepare/submit to show what is left" gives concrete when-to-use guidance and names two sibling tools. It lacks explicit when-not conditions (e.g., that it's unnecessary after submission), but the context is clear enough to route the agent correctly.

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?

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so safety is covered. The description adds genuinely new behavioral context beyond them: it is free and makes no provider call, which is exactly the kind of cost/latency trait an agent needs when deciding to run diagnostics.

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 covering what, when, and cost, with the purpose front-loaded and no filler. The phrasing is telegraphic ("Explain local worker heartbeat") but nothing is redundant.

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 with zero parameters the schema burden is nil. What/when/cost are all present; the only gap is how this diagnostics call relates to the other status- and limit-reporting siblings.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline is 4. No parameter-level detail is required or missing.

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?

Names a specific verb ("Explain") and concrete resources (local worker heartbeat, queue, budget), so an agent knows it returns diagnostic state rather than raw status. It does not, however, differentiate itself from overlapping siblings such as arsenkin_status, arsenkin_task_status, or arsenkin_limits.

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 when jobs stay queued" gives a clear, actionable trigger condition. There is no guidance on when-not to use it or which sibling to prefer when the problem is budget- or status-related, so it stops short of full routing 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?

Annotations already mark this as a non-read-only write (readOnlyHint=false) with destructiveHint=false, and the description adds materially: the write is limited to an 'approval record only' and incurs 'no spend'. That clarifies the blast radius in a way the annotations alone do not, though it says nothing about reversibility or the non-idempotent behavior the annotation flags.

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 clauses, front-loaded with purpose, then precondition, then write scope. No filler and every sentence earns its place.

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

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

An output schema exists, so return values need not be described, and annotations cover the safety profile. However, the tool's core input — the payload that defines the job being approved — is completely opaque in both schema and description, leaving the agent unable to construct a correct call.

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

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

Schema description coverage is 0% for both required parameters, and the description adds no meaning for 'profile' or the nested 'payload' object beyond the vague notion of a 'job'. With the payload schema wide open (additionalProperties: true, no defined properties), this is the tool's critical gap and the description does not compensate.

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

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

States a specific verb and resource ('Create a bounded approval for one paid job') and implicitly differentiates from the batch sibling by scoping to a single job. An agent can tell this apart from arsenkin_batch_prepare and arsenkin_estimate 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?

Gives an explicit sequencing precondition ('Use after the user saw the estimate') and names the follow-up tool ('then arsenkin_submit'). It stops short of naming the alternative to use instead when multiple jobs are involved (batch_prepare), but the trigger context is clear.

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

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

Annotations already cover readOnly, idempotent, non-destructive and closed-world behavior, so the bar is lower. The description goes beyond them by disclosing the cost model ('free, no provider call'), which tells the agent this call has no billing or external side effects. It adds no return-format or freshness detail, but the output schema covers returns.

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 clauses, each earning its place: what it lists, when to call it, and the cost/resource pointer. Front-loaded with the resource before the routing and cost notes.

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 zero-param read-only catalog tool with an output schema and rich annotations, the description supplies everything an agent still needs: the entry-point role, the profile-selection guide, and confirmation of no provider cost. Nothing required to invoke it correctly is 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a 0-param tool is 4.

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') over a specific resource ('job profiles, payload fields and examples'), which is unambiguous against siblings like arsenkin_estimate, arsenkin_prepare and arsenkin_submit. The 'Use first to build a payload' framing further separates it from the tools that consume its output.

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

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

Gives clear sequencing guidance ('Use first to build a payload') and routes profile selection to the arsenkin://guide/tools resource. It does not name a competing sibling or state when-not-to-use, but the entry-point context is explicit enough that an agent knows where this fits.

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?

Annotations already declare readOnly=true, idempotent=true, destructive=false, so the safety profile is covered. The description adds genuinely new behavioral context: it never triggers a scan (no side effects) and costs nothing, which matters for an agent deciding whether to call it. Return-shape details are covered by the output 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?

A single front-loaded sentence with the read scope first, then routing guidance, then cost. No filler, though the clause-dense enumeration of report types could have been tightened.

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 26-parameter, multi-report read tool the description is far too thin: it never explains which optional parameters apply to which report value, no pagination guidance, and no explanation of how the many filter params combine. The output schema helps with returns but not with invocation.

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

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

With 26 parameters at 0% schema description coverage, the description carries full burden, yet it explains only the required 'report' dimension loosely (the listed categories map to the report enum). The other 25 parameters – pagination, filtering, tag/group selection, date ranges – are undocumented in both places.

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

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

States a specific verb ('Read') and resource ('saved Arsenkin Projects data') and enumerates the report families (projects, regions, competitors, keywords, positions, charts). This differentiates it from the sibling action tools (submit, prepare, estimate, cancel) which initiate work rather than read saved data.

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

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

'Use for tracked-project reports; never starts checks' gives both a positive context and an explicit exclusion that separates it from the check-running siblings. It stops short of naming a specific alternative for non-project data, but the boundary is clear.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds genuinely non-structured context: the cost is free, which matters in a paid-API toolset, and that the check is against a persistent ledger. It does not discuss rate limits or return semantics, but an output schema exists to cover the latter.

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

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

Three short sentences that are front-loaded with the core purpose, followed by the trigger condition and the cost note. Every sentence carries information an agent needs; 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?

Purpose, timing, and cost are covered, and the existing output schema handles return values. However, for a tool whose only parameter is completely undocumented, the missing link between 'request_hashes' and the submit response an agent must have previously received leaves a real gap in invocation readiness.

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

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

Schema description coverage is 0% and the description is silent on the sole parameter. It never explains what a request hash is, where an agent obtains one (presumably from a prior submit response), or that multiple hashes may be passed in one call. With one undocumented parameter, the description fails to compensate for the coverage 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 and resource: look up whether an identical request is already in the ledger. The 'ledger' framing makes it naturally distinguishable from siblings like arsenkin_submit, arsenkin_get_result, and arsenkin_status without needing to name them explicitly. It stops short of 5 because no sibling is referenced by name to sharpen 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?

'Use before resubmitting after an unknown outcome' gives a concrete, actionable trigger condition rather than vague context. It does not name an alternative tool or state a when-not case, so it falls short of the explicit routing that would earn 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?

Annotations already declare readOnly, idempotent, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds cost transparency ("free, no new paid calls"), which is genuinely useful and not in the schema, but leaves details like how the table is produced or with what data scope unaddressed.

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 tightly written sentences with zero waste; the core capability is front-loaded and supplemented by the usage cue and cost note. Nothing irrelevant is included.

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 explained, and annotations cover behavior. However, with 0% schema coverage on 5 params — notably the required 'view' — the description should clarify valid inputs and does not, leaving 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% across 5 parameters, so the description must compensate, and it does not. It hints at a type choice (URL/host frequency vs cluster) that likely maps to the required 'view' param, but names none of job_id, view, format, max_rows, or result_pointer.

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 (Build) and resource (SERP URL/host frequency or cluster tables) from a saved result, and distinguishes the output from raw results. An agent can tell this is a table-generation tool rather than a retrieval tool, though it doesn't name a specific sibling.

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 for reports instead of raw results" gives a clear context of use and implicitly contrasts with raw-result siblings like arsenkin_get_result. It stops short of naming the alternative or listing when-not to use it.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds a genuinely useful behavioral fact not present in annotations — that the call is free — which matters for an agent deciding whether to poll. It does not describe what the availability check returns, but the presence of an output schema lowers that burden.

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

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

Three short front-loaded sentences: what it does, when to use it, and what it costs. Every sentence carries distinct information 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 zero-parameter availability probe with rich read-only/idempotent annotations and a full output schema describing the return, the description supplies everything an agent needs: purpose, trigger, sibling routing, and cost. Nothing material is 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. Schema coverage is 100% and additionalProperties is false, so call shape is unambiguous.

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 ('Check') and resource ('Arsenkin account/API availability'), and explicitly distinguishes itself from the sibling `arsenkin_limits` by routing limits queries elsewhere. An agent can identify this tool without opening any 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?

Gives an explicit trigger condition ('Use when jobs fail') and names the alternative tool plus the condition that selects it ('for limits use `arsenkin_limits`'). Both when-to-use and the sibling routing are stated 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?

Annotations already declare destructiveHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered. The description still adds real value by disclosing the cost model ('spends Arsenkin limits (see estimate)') and the non-blocking return behavior ('returns job_id without waiting'). It does not elaborate on the irreversibility implied by destructiveHint, which keeps it short of a 5.

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

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

Three tightly-packed sentences lead with the action and result, then the precondition, then the cost and dependency. No filler; every clause conveys operational information.

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

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

An output schema exists, so return values need not be documented, and the description still names the job_id return. The approval gating, cost, and polling path are all covered. The remaining gap is the opaque nested `payload` and `profile` arguments, which no field documents.

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% with four required parameters, so the description carries the full burden and only partially meets it. It clarifies where approval_id comes from and hints at cost via estimate, but `profile`, the nested `payload` object, and `idempotency_key` are never explained in prose or 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 and resource ('Queue an approved paid job; returns job_id without waiting'), including the async semantics of the operation. It also implicitly separates this tool from `arsenkin_prepare` (which produces the approval) and `arsenkin_task_status` (which polls the result), so an agent can place it in the workflow without opening another 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?

Explicit preconditions are given: 'Use only after the user's explicit OK' and 'requires approval_id from `arsenkin_prepare`'. The follow-up action is also named ('poll `arsenkin_task_status`'), so the when-to-use and what-next guidance is complete.

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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and closed-world, so the safety profile is covered. The description adds non-obvious context the annotations do not: the status is durable (persists across sessions), the intended workflow is polling, and the call is free of cost.

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 clauses with zero padding; the purpose leads, the usage rule follows, and the cost note is tacked on last where it belongs. Nothing is repeated from the annotations or 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?

An output schema exists, so return-value documentation is unnecessary, and the annotations carry the safety profile. Given a single-parameter polling tool, the description covers purpose, timing, follow-up alternatives, and cost — enough for correct invocation.

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

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

One required parameter with 0% schema description coverage, so neither schema nor description formally defines `job_id`. The name is largely self-evident and the description implies it identifies the submitted job, but no format, origin, or failure mode (e.g. unknown/expired id) is described.

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 ("Read durable status of your job"), so an agent knows it retrieves job state rather than mutating anything. It does not, however, distinguish itself from the sibling `arsenkin_status`, whose name suggests an overlapping capability; that ambiguity is left unresolved.

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 names the triggering condition ("poll after submit") and routes the agent to the correct follow-up tools once the job completes (`arsenkin_get_result` or `arsenkin_result_table`). This is when-to-use plus named alternatives, which is the top of the rubric.

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