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 conveys that the URL is invalidated, but says nothing about whether revocation is reversible, whether it requires ownership of the job/grant, what happens if the URL already expired, or whether the call is idempotent.

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 the action and object front-loaded and zero filler. It is efficient, though it is terse to the point of being under-specified rather than genuinely well-structured.

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 two-parameter tool with no annotations, no output schema, and zero schema coverage, the description should at minimum identify the identifiers and the expected effect. Only the surface purpose is covered; everything needed to actually invoke it 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?

Schema description coverage is 0% and the description mentions neither job_id nor grant_id, so the agent has no idea what these identifiers are, where to obtain them, or how they relate to each other. It also omits that both are optional, which is unusual for a revocation call.

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 (revoke) and resource (temporary asset URL), which is clearly distinct from the sibling markovo_asset_url that presumably mints such URLs. It stops short of explicitly naming that sibling or the condition that routes between 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?

The phrase 'before it expires' implies the tool is for early invalidation rather than waiting out the TTL, but there is no statement of when to prefer revocation over simply letting the URL lapse, no prerequisites, and no reference to any sibling 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, the description carries the full burden. It does disclose meaningful traits: the URL is revocable, lives 60-600 seconds, and is a bearer token (implying anyone holding it gains access). It omits authentication requirements for minting the URL, rate limits, and what happens at expiry.

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; the key constraints (revocable, duration range, single-image scope) all arrive immediately.

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 no output schema and no annotations, the description conveys the essential nature of the result but leaves gaps: it does not say a URL string is returned, why all three parameters are optional, or how the returned URL relates to revoke/expiry handling.

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

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

Schema description coverage is 0% across three parameters. The description accounts for expires_in_seconds (and merely restates the schema's own 60-600 bounds) and gestures at asset_path via 'one Bundle image', but job_id is never explained and the '^assets/' path constraint is unaddressed.

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

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

The description uses a specific verb and resource: 'Create a revocable ... bearer URL', with scope narrowed to 'one Bundle image'. This clearly separates it from markovo_asset_revoke (which removes such URLs) and markovo_convert_url, though it never names a 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?

There is no statement of when to use this tool versus alternatives, no mention of its natural pairing with markovo_asset_revoke for cleanup, and no prerequisites. Usage is only weakly inferable from the word 'Create'.

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 implies a read-only safe return but omits key details such as authentication requirements, URL lifetime, and whether the URL is a billing portal link, leaving significant gaps.

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 repetition. It is appropriately sized for a no-argument tool, though its extreme brevity borders on under-specification.

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 zero parameters and no output schema, the description states what is returned but offers no guidance on when to use it relative to siblings like markovo_usage. An agent knows the action but lacks context for selecting it correctly in a broader billing workflow.

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 scoring rules the baseline is 4. There are no parameter semantics for the description to clarify.

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 'Return' and resource 'secure billing URL', clearly distinguishing it from conversion or job-status siblings. However, it does not differentiate from related tools such as markovo_usage, so it falls short of a 5.

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

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

There is no indication of when to use this tool versus alternatives like markovo_usage, nor any prerequisites or context for invocation. The description provides no usage guidance at all.

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 provided, so the description carries full burden. 'Verify' implies a read-only check but the description doesn't disclose what verification entails, whether the bundle is downloaded first or supplied as a path/URL, what failure modes exist, or what the result means.

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, front-loaded sentence with zero waste. However, the brevity comes at the expense of the missing semantic detail rather than being efficiently informative.

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 no annotations, no output schema, and a 0%-documented parameter, the description is inadequate. It leaves the agent unsure what 'bundle' expects and what a verification 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 coverage is 0% and the description adds no meaning for the single 'bundle' parameter. It's unclear whether bundle is a file path, URL, identifier, or binary content. The one parameter is 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?

States a specific verb (verify) and resource (Markovo bundle), distinguishing it from siblings like markovo_convert or markovo_job_status. It's clear what the tool does, though it doesn't differentiate from a hypothetical verify-revoked-bundle variant among the named siblings.

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

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

No guidance on when to use this tool versus alternatives, nor any preconditions. The description gives no context about when verification is appropriate or what problem it solves in a workflow.

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, and it discloses only that the registry is 'live' (i.e., not static). It says nothing about auth requirements, rate limits, caching, or what the response 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?

A single front-loaded sentence with no wasted words. Brevity is appropriate for a no-arg call, though it comes at the cost of under-specification rather than tight editing.

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, no annotations, and no description of the return value, the definition does not tell an agent what it actually gets back from the 'capability registry' or how to act on it. For a discovery tool whose entire value is the payload, this is a real gap.

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

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

The tool takes zero parameters, so per the baseline there is nothing for the description to disambiguate. No parameter-level gap 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 verb (fetch) and a resource (capability registry), which is more than a tautology, but never clarifies what a 'capability registry' contains or how it differs from sibling discovery tools like markovo_usage, markovo_doctor, or markovo_billing. An agent must guess at the payload to decide between 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?

No when-to-use guidance, no exclusions, and no mention of the alternatives in the sibling list. The agent is left to infer that this is a discovery/introspection call rather than a data operation.

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

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

With no annotations, the description carries the full disclosure burden, and it only hints that the call is credit-metered. It omits whether conversion is asynchronous (the existence of markovo_job_status/markovo_job_assets siblings strongly implies a job-returning workflow), what happens to files already in out_dir, permission needs, and 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 front-loaded sentence with no filler or repetition. It is efficient, though it errs toward under-specification rather than over-verbosity.

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 7-parameter, 3-required conversion tool with no annotations and no output schema, the description is far too thin. It never explains what a call returns (job handle vs converted asset), how it relates to job_status/job_assets, or how credits are consumed against max_credits.

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 14% (only layout_fidelity is documented), so the description must compensate and adds no parameter meaning at all. Ambiguous fields like max_credits (cost ceiling? abort behavior?), capability_id (required or inferred?), and mode ('fast' vs 'accurate' tradeoff) are left unexplained.

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

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

The description names a specific verb and resource ('Convert a supported file'), which is clearer than a tautology. It implicitly distinguishes itself from markovo_convert_url by scoping input to a file, but never explicitly names that sibling or the split between 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?

There is no when-to-use guidance, no prerequisites (API key, credit balance), and no routing to alternatives such as markovo_convert_url for remote sources. The agent must infer usage entirely from the name and schema.

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 two meaningful traits: the fetch is remote/isolated and requires explicit consent. It omits that max_credits is spent and that the call polls for completion (poll_attempts/poll_interval_seconds), which are significant cost and latency behaviors for a 7-param tool.

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

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

A single dense sentence with the precondition (consent) and scope front-loaded, and no filler. Nothing in it 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?

For a 7-parameter tool with zero schema descriptions, no annotations, and no output schema, a one-line description is far too thin. The mandatory credit budget, output directory, and polling parameters are essential to correct invocation and go 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% across 7 parameters, so the description must compensate and largely fails to. It only hints at url being public HTTPS and consent via accept_remote_fetch; out_dir, max_credits, poll_attempts, poll_interval_seconds, and download_format are entirely unexplained anywhere.

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

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

States a specific verb (Convert) and resource (one public HTTPS page) plus the mechanism (Markovo's isolated remote fetch). This implicitly separates it from the local sibling markovo_convert, though the sibling is never named.

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

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

'after explicit consent' signals a required precondition, and 'one public HTTPS page' bounds the use case. However, it never states when to prefer this remote variant over markovo_convert, nor any exclusion conditions beyond the URL type.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it discloses almost nothing: no indication of whether the call is read-only, whether it requires credentials itself, whether it is rate-limited, or whether it mutates any state. The one useful hint is that it inspects client, service, and API-key paths, which at least scopes the check.

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 seven-word sentence with no filler and the key scope front-loaded. It is efficient, though its brevity is arguably under-specification rather than genuine tightness, which keeps it from a 5.

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

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

There is no output schema, so the description should carry the burden of explaining what comes back from a readiness probe and what the agent should do with a failure. Instead it names only the categories checked, leaving the agent unable to interpret results. With no annotations either, the definition is too thin for a tool meant to gate other operations.

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 calibration baseline a 4 applies. The schema is an empty object with nothing to misinterpret, and the description appropriately avoids inventing arguments.

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 concrete verb ("Check") and enumerates the resources being checked (client, service, API-key), so the agent knows this is a diagnostic/readiness probe. It is clearly distinguishable from all ten siblings (convert, job, asset, usage, bundle, capabilities, billing). It stops short of saying what a result means or what the tool actually validates, keeping it from a 5.

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

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

There is no explicit statement of when to call this versus alternatives, nor any prerequisite or exclusion guidance. The word "readiness" faintly implies a pre-flight check before conversion work, but that is inference, not instruction, and the sibling list (markovo_capabilities, markovo_convert) offers no routing help.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses a filtering guarantee ('manifest-verified'), which tells the agent only validated assets are returned, and 'List' implies a read-only operation. It says nothing about behavior for an incomplete job, empty results, pagination, or auth requirements.

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

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

A single front-loaded sentence with zero filler; the resource comes first and the scoping conditions follow immediately. Nothing to trim.

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 one-parameter read tool with no output schema, the description covers what is returned at a high level and notes the precondition. It leaves out how results are shaped or ordered and what happens when the job is not complete, which for a listing tool is a real gap.

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

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

Schema description coverage is 0% for the single job_id parameter, so the description must compensate and does not: it gives no hint about the ID's format, source, or whether it is required. 'job_id' is largely self-explanatory, but the gap is left entirely unaddressed.

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 ('List ... image assets') with two useful qualifiers: the results are 'manifest-verified' and scoped to a 'completed job'. That is enough to distinguish it from siblings like markovo_asset_url or markovo_bundle_verify, though it never explicitly names a sibling or contrasts scope.

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 'for a completed job' implies a precondition (the job must be finished, likely requiring markovo_job_status first), but no explicit when-to-use/when-not guidance or named alternative is given. Usage is only inferable.

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 exist, so the description carries the full burden. 'Fetch' implies a read, but it says nothing about authentication requirements, whether the job can expire or be queried after completion, retry/polling expectations, or what a job in progress looks like. For a job-status tool these are exactly the behaviors an agent needs.

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

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

It is a single short sentence with no padding, but its brevity comes from under-specification rather than economy – there is nothing to front-load because almost no information is communicated.

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 one undocumented parameter, no annotations, and no output schema, the description is the only source of behavioral information and it supplies essentially none: not the return shape, not polling guidance, not error conditions. It is inadequate for a job-lifecycle tool.

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

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

There is one parameter (job_id) with 0% schema description coverage, and the description never mentions it. It does not say where the job_id comes from (presumably returned by a sibling tool) or what format it takes, so the description fails to compensate for the schema gap.

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

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

The description gives a verb and resource ('Fetch a remote job'), but the name promises job status while the text says only 'fetch a remote job' – an agent cannot tell whether this returns the job's status, its metadata, or the job's result. It doesn't distinguish itself from siblings like markovo_job_assets or markovo_convert.

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 guidance, no mention of polling semantics or how it relates to the job-producing siblings (e.g. markovo_convert_url, markovo_convert). The agent must infer that this is the status-check counterpart to a job-creating 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, and it discloses almost nothing: not whether this is a safe read, whether authentication is required, what the returned usage data contains, or how far back it covers. For an account-data-fetch tool this is a significant gap.

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

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

A single short sentence that is front-loaded and waste-free. It is slightly terse to the point of under-specification, but nothing redundant is present.

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 is the only source of truth about what this returns, and it does not describe the response at all. For a zero-param tool that could have been fully covered in one extra clause, this 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?

The tool takes zero parameters, so per the rubric the baseline is 4; there is nothing schema-wise the description needs to compensate for. No parameter meaning is missing because none exist.

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 ('Fetch') and resource ('account Credit usage'), so the intent is clear without opening a schema. However, it does not distinguish itself from the close sibling markovo_billing, which plausibly covers the same credit/usage domain, leaving an agent to guess which one to 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 guidance on when to use this tool versus alternatives such as markovo_billing or markovo_capabilities. The description implies a read of usage data but provides no trigger conditions, prerequisites, or exclusions.

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