qart.uk QR studio

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

With no annotations, the description discloses key behavioral traits: it is the anonymous shelf, identical to what a signed-out visitor sees, and codes may 403 on claim. This goes beyond a bare purpose statement, though it doesn't cover aspects like pagination or response structure (not critical for a 0-param list).

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 focused sentences, with the core function stated first. Every clause earns its place: the anonymous-shelf clarification, the usage suggestion, and the cross-reference to the sibling tool. No fluff or redundancy.

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

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

For a 0-parameter tool with no output schema, the description covers what it does, who it's for, when to use it, and a critical limitation (403 on claim). It also points to the correct alternative, making it self-sufficient for the agent.

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

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

The schema has zero parameters, so there is nothing to explain. The description adds relevant context about the selection scope ('one per style') and preview image URLs, which is more than enough given the parameter-free interface.

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

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

The description opens with a precise verb and resource: 'List the QR artwork currently claimable for free on qart.uk, one per style, with a preview image URL for each.' It fully differentiates from sibling tools by explicitly naming browse_my_pool as the signed-in alternative.

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?

Clear usage context is provided: 'Use it to show someone what is available or to describe the styles on offer.' It also gives explicit when-not guidance, warning that signed-in accounts should use browse_my_pool instead to avoid 403 errors, and explains why.

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 present, so the description carries full behavioral disclosure. It reveals the exact HTTP flow (GET → 402 → retry with PAYMENT-SIGNATURE header), explains settlement logic (charged only if a QR detector decodes), specifies payment method (USDC on Base, no ETH needed), and clearly states the tool does not execute the purchase but only returns the request. This is thorough and non-misleading.

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 organized into clear paragraphs with front-loaded purpose in the first sentence. Every sentence contributes: how to use, when to use, payment mechanics, and critical limitation. It is appropriately sized for the tool's complexity and contains no filler or redundancy.

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

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

Despite having no output schema, the description explains exactly what the tool returns (live price and exact request). It covers the full context: prerequisites (wallet, no account), process (HTTP flow), settlement, payment network, and the MCP limitation. For a tool of this complexity, the description is complete and leaves no major operational ambiguity.

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 input schema provides 100% coverage with descriptions for both `url` and `size`, so the baseline is 3. The description adds minimal semantic value beyond the schema: it shows how `url` is used in the HTTP request ('GET https://qart.uk/api/v1/qr?url=...') but does not elaborate on `size` beyond what the schema already states. No additional parameter details are needed.

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+resource: 'buy ONE finished QR artwork' and immediately clarifies that it 'Returns the live price and the exact request to make,' which is distinct from merely purchasing. It also explicitly differentiates from siblings by noting that get_credit_packs and Studio tools require an account or OAuth token, while this tool does not.

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 explicitly states when to use this tool: 'the right tool when you have a wallet but no qart.uk account.' It names alternatives (get_credit_packs, Studio tools) and explains why they are unsuitable. It also clearly states a limitation: 'Cannot be performed through MCP itself' and instructs the user to make the HTTP call externally, providing a complete when/when-not guide.

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 full burden. It discloses that the tool returns 'current text' and that pricing/allowances change, implying dynamic content and read-only behavior. However, it does not explicitly state side-effect-free nature or any prerequisites, limiting transparency.

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 two sentences, front-loaded with the tool's purpose and includes usage guidance without fluff. 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?

For a simple tool with one optional parameter and no output schema, the description covers purpose, usage, and key behavioral context (current text, changing data). It lacks explicit mapping to all enum values and return formatting, but is adequate for the tool's simplicity.

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

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

The schema already provides 100% coverage for the single 'topic' parameter with enum values and a description. The description adds color by listing example topics like scan verification and Studio pricing, but does not map them explicitly to the enum values. Thus it adds marginal meaning beyond the 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 uses the specific verb 'Explain' with the resource 'how qart.uk works' and lists concrete aspects (scan verification, retargeting, free claim pool, Studio pricing, credits). This clearly distinguishes it from sibling tools like buy_qr_outright or resolve_qart_code, which perform actions rather than explanations.

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 explicitly advises to 'Use this before guessing at product details' and notes that 'pricing and allowances change and this returns the current text.' This gives clear when-to-use context, though it does not name specific sibling tools as alternatives for different tasks.

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 discloses that the tool is anonymous, acts as a price list, and that pack prices can change. However, it doesn't detail response shape or error behavior, though that's less critical for a simple list.

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

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

The description is front-loaded with the core purpose, then appends operational guidance about purchasing. While slightly longer than strictly necessary, the extra context is valuable.

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 tool with no output schema, the description provides complete context: what it returns, that it's anonymous, and even next-step actions for purchasing. It fully equips an agent to use the tool and act on its results.

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 input schema has zero parameters, so description is not required to explain parameters. It adds meaning by describing the content of the returned list.

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

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

The description clearly states that the tool lists Studio credit packs, their USD prices, and approximate image yields. This explicitly distinguishes it from sibling tools like buy_qr_outright by establishing it as a price list resource.

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 instructs agents to consult this list rather than recalling prices from memory, and distinguishes between self-service top-up (POST /api/qart/x402/credits) and human-only Stripe checkout. This provides clear when/alternatives 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?

Without annotations, the description takes full responsibility for disclosure. It states the tool has no API, is browser-side, returns no scan verdict, error correction should stay at H, and stricter detectors like zbar reject phone-grade output. It even cautions to treat output as untested until physically scanned. This is thorough and honest about limitations.

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?

Despite being long, the description is front-loaded with the core purpose, then uses short paragraphs for non-generation, usage pairing, and limitations. Every sentence adds essential information; no fluff or repetition.

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

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

Given there is no output schema and no annotations, the description is remarkably complete. It explains what the tool returns, what it does not do, what to pair it with, and practical caveats about scan reliability. An agent would have enough context to invoke it correctly and interpret its role.

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 has zero input parameters, so the schema is trivial and the baseline is 4. The description adds context about the nature of the parameters it returns (ranges, defaults, algorithm order), which helps understand the output but does not need to explain input semantics since there are none.

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

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

The description clearly identifies the tool as an information-returning tool that provides 'the parameters, ranges, defaults and algorithm order' for qart.uk's dithered photo QR recipe. It distinguishes itself from siblings by explicitly stating it generates nothing and pointing to get_qr_matrix for the module grid.

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

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

It gives clear context: the tool is for implementing the technique yourself ('so that YOU can implement it or instruct someone who will') and it should be paired with get_qr_matrix. However, it does not explicitly enumerate alternative tools or state when not to use this tool, relying on the pairing note and the 'generates nothing' caveat to guide selection.

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

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

With no annotations, the description carries full burden and exceeds it: 'Costs nothing, mints nothing, stores nothing' discloses side effects; 'Both come back as one row string per row' describes return format; 'canonical and untransformed' explains transformations are left to the caller. This goes far beyond a minimal disclosure.

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

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

The three-paragraph structure front-loads the purpose, then provides usage context and exclusions. Every sentence earns its place: the function-pattern explanation, the two 'Do NOT' exclusions, and the canonical/untransformed note are all essential and non-redundant. No 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 29 parameters, no output schema, and no annotations, the description is remarkably complete. It explains the output format (row strings), the semantic distinction between function patterns and data modules, when to use, when not to use, and the untransformed nature of the matrix. An agent has enough context 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?

The input schema has 100% coverage with per-parameter descriptions, so the baseline is 3. The description does not add parameter-specific meaning beyond the schema; it focuses on output and usage. It does not compensate for any gaps because there are none, but it also doesn't elevate understanding of parameter semantics beyond what the schema already offers.

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

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

The description opens with a specific verb and resource: 'Return the actual QR MODULE GRID for a payload — the black/white matrix, plus a per-module map...'. It clearly distinguishes from siblings by contrasting with preview_qr_encoding and qart.uk products, making the purpose unmistakable.

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 states when to use ('when you are going to RENDER or transform a QR yourself') and when not to use ('Do NOT use it to check whether a payload fits — preview_qr_encoding... Do NOT use it to get a qart.uk product'). This is textbook-level usage guidance with named alternatives.

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

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

With no annotations, the description fully discloses behavior: costs nothing, mints nothing, returns metadata only, never module grid. It also explains qart_code behavior (16-byte link) and ECC/module trade-offs, far beyond minimal expectations.

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?

Four short paragraphs, front-loaded with purpose, no filler. Each sentence carries distinct info (purpose, usage, qart_code note, clarity on outputs).

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 21 params and no output schema, the description enumerates the return fields (string, byte length, version, module count, capacity, warnings) and explains the tool's scope (metadata only). It also points to the sibling for the actual matrix, making it self-sufficient.

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 baseline is 3. The description reinforces qart_code semantics already present in schema and mentions flat sibling properties for fields, but adds little new param-level meaning beyond the 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 opens with 'Work out how a payload will encode as a QR code, without creating anything', a specific verb and resource. It lists concrete outputs and explicitly contrasts with get_qr_matrix, making it distinct from 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?

It provides direct usage examples ('Use this to answer questions like...') and names the alternative for actual matrix generation ('call get_qr_matrix'). It also advises comparing qart_code vs normal before printing, giving clear when-to-use context.

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 full responsibility for behavioral disclosure. It reveals that the tool returns either targetUrl or disabledReason, that it does not count as a scan, and that it only handles the '_' class codes. This gives the agent a clear picture of side effects and outcomes.

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 three sentences, dense and free of fluff. Every sentence adds relevant detail: purpose, accepted input forms, return behavior, scan-count caveat, and code-class restriction.

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

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

For a simple one-parameter tool with no annotations and no output schema, the description is fully sufficient. It explains the operation, input normalization, output possibilities, and exclusions, leaving no significant gaps for the agent to guess.

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% for the single 'code' parameter, so the baseline is 3. The description adds value by showing accepted input variants (alias, with slash, or full URL) and reinforces the '_' class restriction, which helps clarify normalization beyond the schema's examples.

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

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

The description clearly states a specific verb and resource: 'Resolve a scanned qart.uk code to the URL it currently points at.' It distinguishes itself from sibling tools by explicitly scoping to the '_' code class and excluding older link shapes.

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

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

The description gives clear when-to-use and when-not-to-use guidance: it applies to '_' codes only, not older qart.uk links. It also notes that resolution does not count as a scan, which is useful context, though it does not explicitly name an alternative tool.

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