Polyfork low-poly 3D assets

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

With no annotations, the description carries the full behavioral burden, and it does so thoroughly. It discloses that the tool 'NEVER charges anything itself,' that payment happens on the Stripe page with user approval, that a key is optional, and that `confirm` verifies payment and activates the plan. This is exactly the kind of side-effect and flow context 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?

The description is long but every sentence earns its place: it front-loads the core purpose, then explains safety, usage triggers, key behavior, and post-payment confirmation. There is no filler or repetition; the structure moves naturally from what to how to when.

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 output schema and no annotations, this description is remarkably complete. It explains the no-argument listing mode, the checkout-link flow, the payment page, account creation behavior, and the confirm step with its API-key result. An agent has everything needed to call the tool correctly in all intended scenarios.

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?

Although the schema covers both parameters, the description adds crucial semantics beyond the raw schema: omitting `plan` lists what is on sale, and `confirm` must be the 'WHOLE' checkout_id, potentially with a second part after a dot, and it reports payment status. This transforms simple property names into actionable instructions.

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: 'Buy a Polyfork plan: Pro (monthly or yearly) or a one-payment lifetime seat.' It also clarifies the tool's actual role—returning a Stripe Checkout link rather than charging—so an agent can distinguish it from a direct payment tool. This is far beyond a tautology and clearly identifies what the tool does.

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 the tool: 'Use it when a download needs a plan the user does not have and they say they want it, rather than sending them off to find the pricing page.' It also gives concrete usage patterns for both modes: calling with no arguments to list sale prices and calling again with `confirm` after payment. This leaves no ambiguity about when or how the tool should be invoked.

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 behavioral burden and does disclose non-obvious traits: prioritized ordering (kit > palette > scale), deliberate class diversification, and that the response includes a ready preview URL. It does not cover cost, auth, or failure behavior, but the ranking and diversification semantics are the traits an agent most 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?

Two sentences, zero filler, and the core behavior (what it returns and in what order) is front-loaded before the usage cue and the return note. The density is justified by the ranking rules it conveys.

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

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

For a 6-parameter tool with no annotations and no output schema, the description covers the conceptual model and return shape reasonably but leaves a real gap around the compact/full row distinction, default and max limit, and triangle-budget behavior – all of which change what the agent receives.

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 67%, so roughly a third of parameters rely on inference, and the description adds no meaning about any parameter – not 'compact', not 'limit', not the triangle bounds, and not the 'free' filter. The only return hint ('ready preview URL') is about output, not inputs.

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 ('Given one asset, return assets that BELONG IN A SCENE WITH IT') and goes further to spell out the ranking logic: same kit, then palette, then scale, spread across classes. An agent can distinguish it in spirit from search_assets (query-driven) without opening schemas, though no sibling is named outright.

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?

Provides a clear triggering context: 'Use this to turn a single pick into a scene,' which tells the agent this is a follow-on to selecting one asset. No explicit 'do not use when' or named alternative such as search_assets, so it falls short of 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?

With no annotations, the description carries the full behavioral burden and does substantial work: it discloses conditional return content (gait/arm block only when has_ik is true), the paid-asset response shape (PLAN + pricing link), and a hard pricing policy that prevents a costly agent error. It omits auth requirements, rate limits, and error behavior, but covers far more than a typical read 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?

Front-loaded with the primary return contents, then conditional blocks, then the pricing caveat — a sensible ordering with no filler sentences. It is dense and slightly run-on, and the trailing "Probe #415" is unexplained noise that does not 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 must describe returns, and it does so thoroughly including the conditional IK block and the paid-asset edge case. It is nearly complete for a read tool; only auth/permission expectations and failure modes are 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?

Only one parameter, and the schema already documents it at 100% coverage including the format example (windmill-3aad49). The description adds no syntax or constraint detail beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource ("Full detail for one asset") and enumerates what detail means: size, triangle count, palette, animatable parts, renders, download URLs. This clearly separates it from search_assets or list_kits, but it never names a sibling tool explicitly, so differentiation is by inference rather than by 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?

Usage is implied (fetch full detail for a single asset once you have its id) and there is operational guidance for the paid-asset case ("quote the PLAN... never quote one"). However, there is no explicit when-to-use vs when-to-use-an-alternative routing against siblings like get_variant or preview_scene.

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 burden, and it does disclose useful substance: it names the rule classes returned (real-world metres, one material, no rescaling to fake a fit) and implies a reference-only operation with no side effects. It does not say outright that the call is read-only or describe the shape/length of the returned guidance, 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?

Two sentences, zero filler, front-loaded with the tool's purpose before the call conditions. The parenthetical examples of rules earn their space by making the tool's value concrete.

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 read-only help tool with no output schema and no annotations, the description is nearly complete: it says what topics exist and when to invoke it. The only gap is that it does not indicate how the guidance is returned (structured sections vs. prose) or that the topic parameter selects among those sections.

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 optional parameter with full schema description coverage and an enum of topics, so the schema already does the work. The description complements it only indirectly by naming what the guidance covers (metadata, scenes, rules), without mapping content to specific topic values. Baseline 3 is appropriate given 100% coverage.

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 concrete statement of what the tool provides: server documentation covering metadata semantics, common-mistake rules, and worked scene-building recipes. That makes it immediately distinguishable from every sibling, all of which operate on assets, kits, or terrain rather than on guidance.

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 two explicit triggers — when a tool behaved unexpectedly, and before a multi-step build — plus an explicit exclusion ('instead of guessing'). An agent knows both when to call it and what failure mode it prevents.

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 most of it: it discloses that kits fill incrementally, that no kit is sold as a bundle, that parts are free with no account for /cdn files, and that `layout` only appears when the connection owns the kit. It also warns compact:false is a large result for a 60-part kit. It stops short of error behavior or pagination/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 first sentence is well front-loaded, but the body drifts into scene-setting prose about photographing the Coral Reef through 2.5 m of water and repeats 'photographed and filmed'. Worthwhile content (build routing, ownership-conditional layout) is present but interleaved with marketing-flavored 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?

No output schema exists, and the description does describe the return shape: shortlisting rows, the extra fields under compact:false, and the optional `look`/`terrain`/`layout`/`composition` members with their conditional presence. What a 'shortlisting row' actually contains is delegated to get_asset rather than spelled out, which leaves a small 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 coverage is 100%, so baseline is 3, but the description adds real meaning: compact:false is framed as get_asset-equivalent detail with a size warning, and it states that neither mode is needed if the goal is to build the place. The `id` parameter is only touched lightly (implied to come from list_kits via the schema), which keeps it from a 5.

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?

Opens with a specific verb and resource: every published part of one kit returned as shortlisting rows, plus the compact:false variant. It explicitly differentiates from siblings by naming get_asset (detail parity) and build_the_whole_place (assembly), so an agent can place it immediately.

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 positive conditions (compose a whole scene from one call, works on kits still filling up), an explicit negative routing ('To BUILD that place, do not read the rows: build_the_whole_place'), and a recommendation rule ('recommend its parts rather than the kit'). Alternatives are named, not implied.

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

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

No annotations are provided, so the description carries the full burden. It does disclose genuinely non-obvious behavior: answers carry a `frame`, different kits join on a shared 64m grid, terrain asset ids answer at default knobs while kit ids answer in place.group's coordinates, and `setting` widens the ground. It stops short of stating that the call is side-effect-free and read-only, or whether results are deterministic/cacheable across repeated calls — a meaningful omission for a tool with ten knobs, keeping it at a 3 rather than higher.

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 dense run-on paragraph with several clauses that restate the schema verbatim (the opening "AT WHAT HEIGHT DO I PLACE THIS" is copied from the `at` parameter description), so parts of it are duplicated rather than additive. The key guidance — read `frame`, set position.y — is buried mid-paragraph rather than front-loaded.

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 ten parameters, no annotations and no output schema, the description conveys enough to invoke it correctly in each mode and explains the `frame` convention. But it never sketches the shape of a response (what the flat_areas objects or profile result contain), and gives no contract for why values change between default and override knobs, leaving an agent to discover return structure by calling.

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 the schema itself already documents all ten parameters at length. The description mainly reinforces semantics the schema already gives — `id` as kit-vs-asset, `at` for placement height, `profile` for roads and walls — with little added detail such as default values for `erosion`/`flatten` or what `scatter` points actually look like beyond the schema text.

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 does real work: it names the resource (terrain/ground height) and the specific questions it answers (placement height, level build sites, road grade profiles), and it ties them to concrete consumers (buildKit, place.groundAt(x, z)). The kit-id vs terrain-asset-id distinction lets an agent tell which of two similar-looking queries it wants without opening the 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 when-to-use with the alternative it replaces: "Use it before laying out a town, a farm or a depot, instead of guessing a y and hoping." It also routes within the tool itself — omit id to list kits, pass `at` for point heights off level sites, pass `profile` when a bridge is needed — so each mode has a stated trigger.

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 substantial work: it explains how `want` is resolved against knob names and option values, notes that a knob name beside a number means a range, beside on/off a toggle, beside a hex a colour zone, and discloses a confidence signal that can be below 'high'. It does not state whether the call is purely read-only, what happens on an unmatched `want`, or how the GLB URL is produced, leaving some behavioral gaps for a tool with zero annotation coverage.

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 output contract is front-loaded in the first sentence, followed by matching semantics and then the confidence caveat, which is a sensible order. Every sentence carries information, though the first sentence is overloaded with four parenthetical examples that could be trimmed.

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 3-parameter tool with a nested object, no annotations and no output schema, the description covers the input semantics well and names the GLB URL return so the agent knows what comes back. Missing are failure modes — invalid id, an unmatched `want`, or what an empty result looks like — which matter because there is no output schema to fall back on.

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 67% and the description adds real meaning beyond it for the hardest parameter, `want` — it must use vocabulary from the asset's -params.json, is matched against KNOB NAMES and OPTION VALUES, and explicitly not against colour vocabulary. That is non-obvious and prevents a whole class of failed calls. The `look` object is already well documented in the schema, but `id` is left entirely unexplained 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 concrete transformation: a plain-words request becomes a ready createAsset() call plus a GLB URL of the resulting variant. That is a specific verb-and-output pair an agent can act on. It stops short of naming a sibling (e.g. get_asset or find_matching) as the alternative, so the boundary between this and those tools must be inferred.

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 a clear triggering condition (instances where the user describes a change in their own words) and an operational instruction to check returned confidence and relay applied values rather than presenting a low-confidence match as exact. It also rules out a class of requests — shader effects — and routes them to the asset page. No explicit contrast with get_asset is offered, so it falls short of full when/when-not/alternative 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?

With no annotations, the description carries the full burden and delivers unusually useful context: the two status values and their meaning, the guarantee that filling-up parts are usable today, and the strong warning that price_usd is null and for_sale false on every kit so those fields must not be used to infer status. It omits return shape and pagination behavior, 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?

It is front-loaded with the definition and the usage trigger before the status/pricing caveats, and every sentence carries operational value — particularly the anti-pattern warning about not quoting kit prices. The closing 'Use get_kit to fetch either' is compressed to the point of ambiguity, a minor structural blemish.

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, no output schema, and no parameters, the description supplies the context an agent actually needs to call and interpret the result: what a kit is, when to prefer one, and how to read the status and price fields it returns. It could be slightly more complete by stating that it returns the full set of kits, but nothing critical 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 per the baseline this scores 4. The description correctly spends no space on parameter semantics and instead uses the room for domain context.

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 defines what a kit is ('coherent sets built to one palette and one grid') and implicitly establishes this as the enumeration tool, and it explicitly contrasts with get_kit for fetching a single one. The verb 'list' is only carried by the tool name rather than the prose, so it stops short of a fully explicit 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 gives a clear selection rule — 'Reach for a kit when the user is building a whole environment rather than looking for one object' — which effectively distinguishes it from object-level siblings like search_assets or get_asset. It also routes to get_kit, though 'to fetch either' is ambiguous about what 'either' refers to.

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 burden and discloses key behavior: it returns an openable/orbitable URL, scenes are free and account-free, and paid rows are flagged with sourcing instructions. It does not cover persistence, expiry, or failure behavior, but the main behavioral traits are well surfaced.

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 action and return value, then adds useful usage and licensing context. It is slightly verbose with persuasive framing, but no sentence is irrelevant.

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, but the description explains the return value as a URL and notes paid-item reporting. For a one-parameter preview tool, this is largely complete, though it could say more about URL persistence or invalid-id behavior.

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 has 100% schema coverage and is described as asset ids in any order, up to 24. The description does not add syntax or ordering detail beyond the schema, so the baseline 3 is appropriate.

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

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

The description states a specific verb and resource: compose assets into a scene and return a URL the user can open and orbit. It also makes the output distinction explicit, separating it from handing over three.js code.

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 a clear usage rule: use this instead of giving the user an un-runnable three.js block. It does not name sibling-tool alternatives or when-not-to-use conditions, but the 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?

With no annotations, the description carries the full burden. It explains this is a reporting/feedback call ('a report costs one call and is how this server gets better') and clarifies the four kinds. It does not detail post-call side effects such as whether a record is persisted, but the core behavior is disclosed.

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, well-structured paragraph that is front-loaded with the core purpose. It uses space efficiently to explain the four kinds and a motivational nudge, with no tangential details.

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 reporting tool with a rich schema and no output schema, the description provides enough context: what it does, how to use it, and the meaning of kinds. It does not state the return format, but that is not critical for a fire-and-forget report call; the overall guidance is complete enough.

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 covers all 5 params, so baseline is 3. The description adds substantial meaning to the `kind` enum by explaining each value in context, and provides an example for `need` ('we do not have that'). This raises it above baseline.

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

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

The description opens with a clear verb+resource ('Report a gap'), then enumerates four distinct kinds and explicitly contrasts server-side vs catalogue gaps, making it unambiguous and well-differentiated from sibling tools like search/get.

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 explicit usage guidance: 'offer this whenever a search is empty or thin' for asset kind, and defines scenarios for capability, output, and docs. It also encourages use rather than silence, providing clear context for when this tool is the right choice.

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 a lot: it discloses the no-account CDN access, the free/paid split, and the meaning of coverage states ('none', 'poor', 'filtered_out', 'unmatched_goals'). It also flags a real operational hazard — full detail at limit 50 can be rejected by some clients. It does not describe response shape or pagination beyond the schema's field.

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-loaded with purpose and trigger, then filter guidance, then result-interpretation rules. Every section is useful, but the pricing message spans two sentences that partially restate each other (free catalogue / paid HD edition).

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 read tool with no annotations and no output schema, the description supplies the interpretive context an agent actually needs: what to do on bad coverage, what 'filtered_out' means, and when to use compact. Only the response row shape and sort semantics are left implicit.

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 75%, and the description reinforces the highest-stakes filter semantics: max_triangles is framed as the mobile/performance lever and free/plan are framed as fields to read rather than assume. Niche parameters such as sort, kit, and class are left entirely to 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?

States a specific verb and resource ('Search the Polyfork catalogue of low-poly 3D assets for three.js') and scopes it against siblings by naming report_need as the fallback and pointing to get_asset for full detail. An agent can distinguish it from get_asset, list_kits, and find_matching 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?

Explicit trigger ('use this whenever the user needs a model for a scene, game or site'), an explicit alternative for misses ('offer report_need rather than substituting something unrelated'), and a filter rationale for mobile/performance targets. When-not guidance is present in the coverage-failure branch.

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 burden of disclosing behavior. It explains what information is returned (key status, owned assets/kits, download viability) and implies a read-only diagnostic nature. However, it does not explicitly confirm non-destructiveness or describe the response format.

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, with the first sentence front-loading the tool's purpose and the second providing usage guidance. Every word contributes, and there is no redundancy or 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?

For a zero-parameter tool with no output schema, the description gives sufficient context: what the tool reveals and when to call it. It is almost complete, though it omits the exact return format, which is a minor gap for agents expecting structured output.

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 parameters, so there is nothing for the description to explain. The baseline of 4 applies, and the description adds no unnecessary parameter details.

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 indicates the tool reports the connection's current state: key attachment, owned assets/kits, and download viability. It distinguishes from siblings by focusing on the connection rather than individual assets or kits, though it lacks an explicit verb like 'retrieve' or 'list'.

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 call the tool: 'before promising the user a paid file' and 'when a download 404s'. It provides concrete usage scenarios but does not mention when not to use it or compare to alternative tools.

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