InkRoom

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered; the description adds nothing beyond the word 'Read'. It does not disclose auth requirements, what the two action modes return, pagination behavior, or rate limits.

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

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

A single short, front-loaded sentence with no wasted words, but the brevity comes at the cost of under-specification rather than genuine economy.

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

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

A six-parameter tool with no output schema and only safety annotations demands more from the description. Neither the parameter contract nor the distinction between the summary and usage actions is explained, leaving the agent poorly equipped to call it correctly.

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

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

Six parameters with 0% schema description coverage, and the description explains none of them. 'balance, access or billing usage' faintly corresponds to the 'type'/'action' (summary|usage) fields but offers no syntax, format, date conventions for from/to, or pagination 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 gives a generic verb ('Read') over a vague resource ('balance, access or billing usage'), and the tool name 'account' is itself broad. It hints at the domain well enough to separate it from the image-generation siblings, but the boundaries of what an 'account' read returns are unclear.

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

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

There is no guidance on when to use this tool versus siblings like spending_policy, nor any mention of prerequisites or the summary-vs-usage distinction. The agent must infer usage entirely from the name and the 'action' enum.

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=true, idempotentHint=true, so safety is partly covered. The description adds no behavioral context such as cost, async execution, or what gets modified, and 'execute requestId' is too fragmentary to disclose the run model. It does not contradict the annotations.

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 short, but the brevity is under-specification rather than efficient conciseness: the text is a semicolon-spliced fragment dump with no front-loaded purpose. Sentences do not earn their place because they convey almost no actionable meaning.

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

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

For a 16-parameter, destructive, idempotent generation tool with no output schema and 25% schema coverage, the description is grossly inadequate. It omits execution model, required pairings (e.g., parentTaskId with parentImageIndex), and the meaning of the action enum, leaving an agent unable to call it correctly.

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

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

With 16 parameters and only 25% schema description coverage, the description lists four parameter names (referenceImages, parentTaskId, parentImageIndex, requestId) but gives no semantics, format, or interaction rules. The remaining twelve parameters are undocumented in both the schema and the description, so it 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?

The description never states a clear verb+resource action; it reads as telegraphic notes ('Multiple edits: batch_generate. referenceImages/parentTaskId; ...') rather than a description. The name 'derive_image' plus the annotation title 'Create | Edit from reference' carry the actual meaning, not the description text. It alludes to editing from a reference but doesn't distinguish this from generate_image or upscale_image.

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 hints that referenceImages/parentTaskId are used for batch/multiple edits and that parentImageIndex is 'if needed', but gives no when-to-use this tool versus generate_image or upscale_image. The reference to 'batch_generate' is unexplained and matches no sibling tool. No exclusions or alternatives are provided.

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=false, destructiveHint=true, idempotentHint=true, so the agent knows this is a mutating, non-reversible operation. The description adds only the retry sequencing note and says nothing about cost implications, permission/auth needs, rate limits, or what preview versus run actually does. Against a 12-parameter generation tool with no output schema, that is thin.

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 telegraphic fragments that read like internal notes rather than a front-loaded description of the tool. There is little waste, but the terseness is under-specification rather than conciseness – the retry rule is buried in a clause with no framing sentence.

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 12-parameter, four-enum, mutating generation tool with no output schema, the description is far from complete: it omits the main generation path, delivery modes, reference images, and output format. Only the retry sub-flow is covered, leaving most of the invocation surface 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 only 25% across 12 parameters, so the description must compensate and largely fails to. It clarifies the pairing of retryTaskId with 'preview' and requestId with 'auto', which is real added meaning, but size, count, model, prompt, quality, deliveryMode, outputFormat, thinkingLevel, and referenceImages remain undocumented in both places.

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

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

The description never states the core action; it only implies generation via the tool name and adds routing notes ('Multiple images: batch_generate'). The retry fragment hints at the preview/auto action workflow but doesn't say what a successful call produces. An agent can infer the purpose from the name, but the description itself is vague rather than a clear verb+resource statement.

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 does give one concrete decision rule – for retries, use 'preview' with retryTaskId only, then 'auto' with requestId – which is genuinely useful routing. However, it provides nothing about when to use each action for a fresh generation (preview vs auto vs run), no prerequisites, and no guidance against misuse. Partial, implied guidance only.

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 and idempotentHint=true, so the agent knows cancel is a destructive, repeatable operation. The description adds the anti-polling directive, which is useful context beyond annotations, but says nothing about what cancel does to the task result or about authorization/rate limits.

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

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

The definition is brief and the high-value directive ('never poll') is front-loaded. The trailing example is ambiguous enough that it does not clearly earn 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?

There is no output schema, so the description should hint at what a 'get' returns (e.g., task state/progress), and it does not. Combined with the 0% parameter coverage, the agent has enough to call the tool but not enough to interpret results well.

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 burden for both parameters. It only gestures at syntax with the cryptic 'Example: cancel taskId', never clarifying that action is a separate optional enum, what its default is, or how taskId is obtained.

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?

'Get or cancel one task' gives a specific verb and resource, and the tool is clearly the single-task status/cancel counterpart to the batch sibling wait_images. It is distinguishable from siblings, though it never names 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?

'never poll' supplies one real usage rule: call this rather than polling. However it does not say when to prefer wait_images, nor when to choose get vs cancel, so the guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds one genuine behavioral hint — that this is skippable prior to generation — but says nothing about the response shape (a matrix of what?), whether omitting topic returns everything, or how the content maps to the enum.

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 short with no padding and the noun phrase is front-loaded, but the second clause ("Skip before generation") is cryptic enough that it does not really earn its place. The brevity here reads as under-specification rather than disciplined concision.

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

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

For a help/documentation tool with no output schema and 0% parameter description coverage, the description should say what the returned matrix contains and what the topic enum selects. Neither is explained, so an agent knows to call it but not what it will get back or how to aim the query.

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%, but the single property carries a complete 14-value enum, which effectively documents the valid inputs. The description contributes only the example "topic=models", which adds slight value without explaining what any topic returns or that the parameter is optional (required: 0).

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 offers only the noun phrase "Capability matrix" plus an example topic value; there is no verb stating what the tool does (return static documentation? enumerate supported operations?). For a tool named "help" this largely restates the name rather than distinguishing it from siblings like list_models or account, leaving the agent to infer the real purpose from the title annotation.

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?

"Skip before generation" is the only usage cue and it is ambiguous — it could mean the tool is unnecessary before generating, or that it should be skipped in a pipeline. No condition for when to call help versus list_models, account, or spending_policy is given, and the fact that topic is optional is never mentioned.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds useful content disclosure (what is listed: models, prices, dedicated processing availability), but says nothing about freshness, rate limits, or pagination.

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

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

A single, front-loaded sentence with zero filler. Every clause adds a distinct piece of information about what the tool returns.

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 read-only list tool with no nested objects and no output schema, the description adequately conveys the return content and safety is covered by annotations. The only real gap is the unexplained includeUnavailable parameter, which is a minor but noticeable omission.

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

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

There is one parameter, includeUnavailable, with 0% schema description coverage, and the description never mentions it. The phrase 'dedicated processing availability' gestures at availability but does not explain whether unavailable models are hidden by default or how to include them, so it 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 (List) and resource (image models) plus the fields returned: prices and dedicated processing availability. This clearly separates it from action-oriented siblings like generate_image, upscale_image, and derive_image, though it never names them explicitly.

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

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

The description offers no when-to-use guidance, no prerequisites, and no mention of alternatives. An agent can infer this is a discovery/pricing lookup tool, but nothing in the text confirms that role or rules out other siblings.

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

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

Annotations only flag idempotency and non-destructiveness; the description adds the real behavioural payload — this is an idempotent refund/compensation path, not a regeneration, and the refund trigger set is precisely bounded by HTTP status codes. The enumerated result states (reachable, unconfirmed, refund_pending, refunded) and the pointer to settlement for amounts give the agent the side effects it must anticipate.

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

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

Front-loads the purpose in four characters, then layers conditions, exclusions, and outcomes in dense semicolon-delimited clauses; essentially every clause carries new information. Slightly dense for skim-reading, but 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?

With an output schema present, return values need not be spelled out, yet the description still names the status vocabulary and where refund amounts live, so the agent knows what to expect. Combined with the explicit refund/exclusion rules, nothing material is missing for correct invocation.

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

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

Schema coverage is 100%, so taskId/resultId/imageIndex are already fully documented in the schema. The description only restates that the original taskId and imageIndex must be reused, adding marginal meaning (no new-generation taskId) beyond the schema's own wording.

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

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

States a specific verb+resource: verify/report that the original image download failed, with the exact identifiers to supply. It is clearly distinguishable from generate/derive/upscale siblings, though it never explicitly contrasts itself with the closest neighbour, generation_status, which an agent might otherwise reach for.

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 inclusion criteria (only server-issued links, only explicit 403/404/410) and an explicit exclusion list (timeouts, transient failures, normal expiry, manual deletion, local save failures do not auto-refund), plus the instruction not to submit a new generation. That is a full when/when-not contract.

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 annotations indicating destructiveHint=true and readOnlyHint=false, the description adds substantial behavioral context: updates require full policy and confirmed:true, existing policies remain unchanged, never raise autonomously, and includes domain-specific rules about credits and reservations. This goes well beyond what annotations provide and is very helpful for safe invocation.

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 dense and front-loaded with critical information: read vs update context, credit value, defaults, update requirements. Every sentence carries useful information. It could be slightly more structured (e.g., bullet points for update requirements), but it's efficient and avoids fluff.

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 the tool's complexity (read/update, policy object, destructive potential), the description covers key aspects: consent requirement, default policies, update mechanics, and side constraints. It does not explain the 'action' parameter's expected values or the read operation's return format, but an output schema exists, so return values needn't be described. It's nearly complete but misses a few details.

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

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

Schema description coverage is 0%, so the description must compensate. It does: it explains the policy structure (enabled, taskPoints, fiveHourPoints, dayPoints, weekPoints, revision, unlimited), the need for full policy including unlimited, and confirmed:true requirement. It also clarifies credit conversion and default limits. This adds significant meaning beyond the bare schema, though it doesn't detail the 'action' parameter's allowed values (e.g., 'read' vs 'update').

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 clear dual-purpose tool: read account-wide authorization policy or update it. The verb+resource is specific and distinguishable from siblings like 'account' or generation tools. However, it lacks an explicit statement of when to use this versus 'account', which might also expose policy information, so it's not a perfect 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 description provides strong usage guidance: 'update only with explicit user consent', 'Never raise autonomously', and details about default policies. It clearly distinguishes read vs. update actions. It doesn't explicitly mention alternatives or when not to use this tool (e.g., vs. 'account'), but the context is quite 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 readOnlyHint=false, idempotentHint=true and destructiveHint=true, so the safety profile is covered structurally. The description adds only the single-image constraint and repeats the mode enum, leaving real behavioral questions unanswered: the tool appears asynchronous (siblings wait_images and generation_status exist) yet nothing says whether a job id is returned, and destructiveHint=true is never reconciled with an upscale operation.

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

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

A single short clause with the modes and the exclusion front-loaded and no filler. Brevity here comes at the cost of substance rather than being wasteful, so structure itself is fine.

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 5-parameter, 20%-covered tool with no output schema and a likely async workflow, the description omits parameter meaning, return/status behavior, and any permission or delivery context. It is not adequate to invoke the tool confidently.

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

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

Schema coverage is only 20% across 5 parameters. The description restates the operation enum values but says nothing about action (preview/auto/run), requestId, deliveryMode, or the image URL/data-URL input, so it does not compensate for the documented 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 resource (one image) and enumerates the four processing modes (x2/x4/anime/face), and explicitly carves out scope with 'not general editing', which separates it from editing-oriented siblings. 'Process' is generic, but the mode list plus the tool name upscale_image pin the purpose down.

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 'not general editing' is a genuine exclusion, but there is no positive when-to-use guidance and no routing to the plausible alternatives among siblings (generate_image, derive_image, wait_images). Usage is only implied by the mode 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?

Annotations already declare readOnlyHint and idempotentHint, so safety is covered. The description does add real behavior beyond them: a 24s wait with a 45s ceiling, page sizes per delivery mode, and the instruction to follow nextAction silently. It omits what happens on timeout or on failure, which for a polling tool is material.

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 short and front-loads the timing constraint, so nothing is padded. However, the telegraphic fragments ('Present; follow nextAction silently') are cryptic rather than efficient, trading clarity for brevity.

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 six optional parameters, no output schema, and minimal annotations, the description should carry much more: what is returned, how paging resumes, and what the other identifiers are for. It covers only timing and page capacity, leaving most of the calling contract unstated.

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

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

Schema coverage is only 17% (just cursor), so the description must compensate. It partially does: 'native 6 previews, links 32 originals' gives meaning to the deliveryMode enum, 'max 45' bounds timeoutSeconds, and 'follow nextAction' explains cursor usage. batchId, taskIds, and requestId remain undocumented in both schema and description.

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

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

The description tells the agent it waits (24s, max 45) and paging capacities for native vs links, but never states that it returns images or how it relates to generation_status/generate_image. The verb 'wait' plus the tool name carries the purpose; the body text alone is a fragment, not a purpose statement.

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 or when-not-to-use guidance, no mention of alternatives such as generation_status, and no statement of prerequisites (e.g., needing a batchId or taskIds). The only procedural hint is 'follow nextAction silently', which describes what to do after calling, not when to call.

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