slopped.site

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds genuinely new behavior: checks are 'the same code the lab judge runs', 'no model, nothing stored', and some drafts are rendered/measured or rendered frame-by-frame — signaling deterministic, server-side execution that may be slow. It also discloses the return shape (per-row met/not-met plus judge-only rows), which matters because there is no output schema; it does not mention latency or whether results are reproducible across edits.

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?

Purpose is front-loaded in the first clause and the when-to-use sentence follows immediately. The middle list of draft formats is long but each item disambiguates a real input type; only slight tightening (e.g. grouping the rendered items) would improve it.

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 three-parameter tool with a nested prior map, full schema coverage and no output schema, the description covers purpose, trigger, execution model, and return values. The remaining gap is minimal: it never links to the sibling that issues the receipt after a pass, leaving the learner's next step to be inferred.

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 baseline is 3; the description earns extra by explaining what `prior` actually does — earlier labs' answers supply rows that cross-compare (the example 'a sound must be for an event on your brief'), which is a relationship the schema's per-key descriptions do not state. `draft` and `module` are not elaborated beyond the schema, which is acceptable given the schema already names the module source (list_curriculum) and example values.

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 — 'Run a Slop Curriculum lab's exact checks on a draft' — and then enumerates exactly which draft artifacts qualify (game spec, sound recipe/pack, motion shot, SKILL.md, tool definition, verb/juice table, plan). That enumeration separates it from siblings like validate_cartridge (cartridges) and claim_lab_receipt (which presumably records a pass rather than checking one).

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

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

'Use when a learner wants to know whether their JSON or file passes before they submit' gives a clear triggering condition and implicitly the pre-submission timing. It does not explicitly name an alternative or say when-not to call it (e.g. after a receipt is already claimed), so it stops short of full routing guidance.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=false, so the safety profile is covered. The description usefully adds the scope restriction and the downstream purpose of the return value (paste it back into the lab), but it never addresses idempotentHint=false — an agent cannot tell why repeating the call may produce a different result, or what happens with an expired or malformed learner code.

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

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

Three short sentences, front-loaded with scope and trigger before the return value; nothing is padding. There is mild redundancy between 'returns a receipt proving…' and 'Returns a receipt to paste back into the lab', which costs it the top score.

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 required parameter, no output schema, and full annotation coverage, the description covers what matters: who it is for, when to call it, what goes in, and what comes back. The only missing piece is error/retry behavior for an invalid or already-used learner code.

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 100% and the single parameter carries its own description plus a UUID pattern, so the schema does the heavy lifting. The description only echoes that the code is 'shown in the lab', adding no new meaning about format, lifetime, or failure modes.

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 — it returns a receipt proving the learner connected an MCP client to this server — and scopes it to a named lab ('Tools, not vibes'). That is far more specific than any sibling (verify_badge, check_spec, validate_cartridge), so an agent can distinguish it 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?

It gives an explicit trigger ('Use when a learner asks for their lab receipt and gives their learner code') plus a hard exclusion ('For the Slop Curriculum's “Tools, not vibes” lab only'). It does not name an alternative tool for adjacent receipt/badge needs, which keeps it just 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?

Annotations already declare a pure read/idempotent operation, so the bar is lower, yet the description still adds real behavior: out-of-range numbers are clamped to the family's limits rather than erroring, omitted params keep defaults, and the call returns the link plus a description of the view. It does not say whether the returned link is short-lived or hostable elsewhere, which is the one remaining 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?

Front-loaded with the purpose, then usage, then behavior, then coordinate semantics — a sensible order with no filler. The first sentence is long and list-heavy, but every clause carries scope information.

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

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

No output schema exists, and 'Returns the link and what it shows' is a reasonable but slightly vague account of the return value. For a six-parameter tool with a nested params object, the description plus the fully documented schema cover what an agent needs to call it correctly.

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

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

Schema coverage is 100%, so the schema already documents every property including the '(or yaw for 3D)' note on x and y. The description's centre/zoom paragraph mostly restates that, adding only that zoom means camera distance for 3D families — genuinely useful but a small increment over structured data. Baseline 3 is correct here.

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 ('Build a link that opens fractals.slopped.site on one exact view') and then enumerates the dimensions being fixed: family, parameters, palette, viewing position. The family list gives concrete scope, and no sibling tool does anything comparable, so an agent can select it unambiguously.

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

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

'Use when someone wants to see or share a particular fractal' gives a clear triggering condition. There are no exclusions or alternatives named, but the sibling set contains nothing overlapping, so the omission is low-cost.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds that the image payload is opt-in via include_image and mentions the wallpaper 'if any' and infinite-zoom Scroll, which hints at optional/conditional fields. It does not cover error behavior for a missing id, which is the main remaining behavioral 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?

Two sentences, front-loaded with the resource and its returned fields, then the usage cue. Every clause carries information and there is no filler.

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

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

With no output schema, the description usefully enumerates the return contents, including conditional items like the wallpaper and Scroll. Combined with annotations covering the safety profile, an agent has enough to invoke this 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?

Schema coverage is 100%, so both parameters are already documented, and the description's note that include_image returns 'the picture itself' largely restates the schema. The id parameter's format is left entirely to the schema's pattern and example. Baseline 3 applies when structured data carries the parameter detail.

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

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

Names a specific verb and resource ('Get one Fresh slop piece by id') and enumerates the fields returned (title, category, subtitle, description, links, wallpaper, Scroll), so the agent knows exactly what it retrieves. It also names the two siblings it follows (search_artwork, of_the_day), distinguishing it from list/search tools.

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?

States an explicit sequencing cue: 'Use after search_artwork or of_the_day,' which tells the agent when this is the right next call. It does not state exclusions (e.g., that it fails for unknown ids or that bulk retrieval needs a different tool), so it stops short of full when/when-not guidance.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and open-world behavior, so the safety profile is covered. The description adds genuinely useful behavior beyond that: it discloses that this returns summary-level fields only and that full text lives in a separate resource, which prevents an agent from expecting complete entry content.

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. The field list is front-loaded so an agent can decide relevance immediately, and the usage/alternative note follows in a compact clause rather than a separate paragraph.

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, and the description compensates by naming the returned fields explicitly. Combined with the pointer to the full-text resource and the post-search placement guidance, an agent has everything needed to call this correctly and interpret the result.

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

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

With a single parameter at 100% schema description coverage, the schema already documents the id and even gives a format example. The description's "by id" adds no format, resolution, or error semantics beyond that, so the baseline 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 ("Get one codex entry by id") and then enumerates exactly what comes back: name, aliases, kind, world, summary, games, and the codex.slopped.site page. That level of specificity clearly separates it from the sibling search_codex, which returns multiple entries.

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

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

Gives explicit sequencing ("Use after search_codex") and names the alternative for the full text (the slopped://codex/{id} resource). An agent knows both when to reach for this tool and where to go when the summary fields are insufficient.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so safety is covered. The description adds real behavioral context beyond them: the return format (markdown) and the notable constraint that quiz questions come without answers because learners take the quiz on the site — a detail that prevents an agent from promising answer keys.

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, front-loaded with the verb and resource, then usage. The content enumeration is long but every listed element (lesson text, quiz, lab) is genuinely distinct information an agent needs to plan around.

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, the description carries the burden of describing returns, and it does: it lists the payload sections and states "Returns markdown." That is complete enough for a single-parameter read tool; only the error case for an invalid id is 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?

There is a single required parameter with 100% schema description coverage and a 39-value enum, so the schema does the heavy lifting. The description adds no meaning about the id beyond what the enum already conveys, which is the baseline for full-coverage schemas.

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 ("Get one Slop Curriculum module") and enumerates exactly what the payload contains: abilities, lesson text, quiz questions, lab brief and checklist. It is clearly the singular counterpart to list_curriculum, though it never names that sibling explicitly, so the differentiation is inferred from "one" rather than stated.

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

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

Gives concrete usage context: "Use to explain a topic from the course or to help someone prepare." That is clear when-to-use guidance, but there is no when-not guidance and no explicit pointer to list_curriculum for discovering valid ids (that pointer lives only in the 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?

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds real behavioral value by disclosing the shape of what comes back (ordered pathways, planned-but-unreleased pathways included, per-module fields) and that no parameters are needed. It does not mention volume or pagination, which is the only remaining 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 dense sentence that front-loads the resource and then the payload, with the usage clause and sibling handoff appended. No filler, no restatement of the title, and the parenthetical field list is compact rather than a bulleted dump.

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 carries the burden of describing return content — and it does so concretely, down to individual module fields and the inclusion of planned pathways. Combined with annotations covering safety and a zero-parameter schema, nothing an agent needs in order to call this correctly is missing.

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

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

The tool takes zero parameters, so the baseline is 4; there is nothing for the description to disambiguate. It correctly implies the call is argument-free by framing the tool as a whole-catalog dump rather than a filtered lookup.

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

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

States a specific verb (List) and resource (the Slop Curriculum on learn.slopped.site), then enumerates exactly what the listing contains: ordered pathways including planned ones, per-pathway modules with number/id/title/summary/link, and badge-certified abilities. This is clearly distinguishable from get_module, which is named as the drill-down counterpart.

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 two concrete use cases ('recommend what to learn next' and 'find a module id for get_module') and explicitly routes the agent to the sibling get_module for the follow-up step. An agent knows both when to reach for this tool and what to do after it returns.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds useful return-shape information that no output schema supplies: each site comes back with a one-line description and a link, and the enumerated catalogue tells the agent what coverage to expect.

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, front-loaded with the verb and resource, with the parenthetical catalogue placed before the usage instruction. The site enumeration is long but does real work by signaling scope; nothing else is wasted.

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 read-only listing tool with no output schema, the description covers what the tool returns and when to call it. Ordering, pagination and exact response fields are unspecified, but the catalogue is small enough that this is a minor 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?

There are zero parameters, so there is nothing for the description to clarify beyond what the empty schema already conveys; baseline for a 0-param tool 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 ('List every slopped.site site') and enumerates the concrete scope (main gallery plus Scroll, Games, Learn, the Slopwright, Backrooms, codex, Meinong's jungle, GeoCities), which lets an agent distinguish it from siblings like get_artwork or search_world without opening a schema.

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

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

Gives an explicit trigger condition: 'Use when someone asks what is on slopped.site or where to find something.' It does not name an alternative tool or state when not to use it, so routing when a specific site/artwork is already known is left to inference.

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

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

Annotations already declare readOnly=true, idempotent=true, non-destructive, and closed-world, so the safety profile is covered. The description adds genuinely useful behavior beyond that — deterministic per-date output, UTC basis, and seasonal gating — but says nothing about rate limits, failure modes, or what happens for out-of-season or future dates.

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 core action and the enumerated kinds, followed by constraints and the return shape. The single dense paragraph is efficient, though the parenthetical about ideas.slopped.site is slightly buried and could be trimmed or split for scanability.

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-optional-parameter read tool with no output schema, the description covers it all: what is picked, the determinism and timezone rule, seasonal availability, when to use it, and the return fields (id, name, link, a line about it). An agent has everything needed to call it correctly and interpret the result.

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% and both parameters already carry descriptions including the enum meanings, so the schema does the heavy lifting. The description echoes the kind list and adds a little color about the 'idea' kind (machine-made prompts from ideas.slopped.site, to make or vote on), but adds no syntax or format detail beyond the schema. 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?

Uses a specific verb ('Pick') plus a concrete resource ('the slopped.site thing of the day') and enumerates the possible kinds: artwork, game, codex entry, clock, song, SK8 level, or twelve ideas. It's immediately clear this is a single daily selection rather than a lookup or search, though it never names which sibling (get_artwork, get_codex_entry) to use instead for a specific known item.

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 'Use when someone wants one recommendation or a daily pick,' which sets a clear usage condition and implicitly excludes targeted lookups. It also gives the seasonal constraint (seasonal pieces only in their season) and the determinism rule (same pick for everyone on a given date, UTC), but stops short of naming alternatives for when a user wants a specific item by id.

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?

The annotations already declare readOnly, idempotent and non-destructive, so safety is covered; the description adds real value on top by describing the result payload (ids, titles, page links, image links), the cap at `limit`, and the degenerate no-query behavior. It does not mention result ordering/relevance or what an empty match set looks like, which are the remaining behavioral 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?

Four short sentences, front-loaded with what is searched and immediately followed by when to use it, the return shape, and the follow-up tool. Nothing is repeated from the schema and no sentence is filler.

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

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

For a three-parameter, output-schema-less search tool the description covers scope, matching fields, return fields, and the empty-query case, which is nearly everything an agent needs. Minor omissions are relevance ordering and the zero-results case.

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?

Beyond the schema it clarifies that `query` matches words in title, subtitle or description (the schema only gives examples) and that `category` narrows rather than filters out everything else, plus ties `limit` to the number of matches returned. `limit` itself gets no prose, but its default/min/max are self-explanatory in 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 first sentence names a specific verb (search), a specific resource (the slopped.site art collection), the exact fields matched (title, subtitle, description), and the optional scoping dimension (category). The no-query fallback ('returns the newest pieces') further pins down the tool's behavior so an agent can distinguish it from get_artwork and from unrelated search siblings like search_world or search_codex.

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 use case ('find pieces about a subject or mood') and explicitly routes the agent onward with 'follow up with get_artwork for one piece', which is the key alternative. It does not state when NOT to use it or how it differs from the other search_* siblings, so it stops short of full when/when-not guidance.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds real behavioral context beyond that: the matching fields (names, aliases, summaries), the shape of results (ids, kinds, one-line summaries, links), and the fact that omitting the query lists everything. It doesn't mention pagination or ranking order, which is a minor remaining 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?

Three sentences, front-loaded with the domain identity, then the usage trigger, then the return shape and follow-up. No filler, and each sentence carries distinct information an agent needs to select and chain the call.

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 search with no output schema, the description does the heavy lifting on return values and follow-up resources, which is what an agent needs. The only omission is result ordering/pagination when results exceed the limit of 25, which is a minor but 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 coverage is 67%, so the schema documents most parameters, and the description adds meaning the schema cannot: that the query string is matched against names, aliases AND summaries (not just names). The kind enum is self-documented via its values; limit behavior is left to the schema, which is acceptable.

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 (search) plus the resource and its scope: 'the encyclopedia of the slopped.site world: its people, creatures, places, objects, events, groups and concepts.' It also discloses what fields are matched (names, aliases, summaries), so an agent knows exactly what this tool does versus sibling lookup tools like get_codex_entry.

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 when someone asks who or what something in the slopped.site world is,' and it names the follow-up path (get_codex_entry or the slopped://codex/{id} resource). It stops short of saying when NOT to use it or how it differs from search_world/search_artwork, so the sibling routing is only partially covered.

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

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

Annotations already cover read-only, idempotent, non-destructive, and closed-world behavior, so the description only needs to add beyond that. It does: it names the returned fields (ids, names, types, links, descriptions), explains that ids chain into world_graph or the slopped:// resources, and discloses pagination ('a page at a time').

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

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

Three tight sentences: what is searched, when to reach for it first, and what comes back. The long content enumeration is dense but earned, since it sells the breadth that justifies using this over typed searches, and the routing rule is placed early.

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, the description carries the return-value burden and does so by listing the fields and the id-consumption path. The only shortfall is the lack of detail on the default page size / limit parameter, a minor gap for a four-parameter search 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?

Schema coverage is 75%, with query, types, and cursor already documented inline; only limit lacks a schema description. The description adds the pagination concept implied by 'a page at a time' but gives no detail on limit bounds or how types interacts with query matching, so it is roughly at the baseline for high-coverage schemas.

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 everything in the slopped.site world by words') and enumerates the content families covered (artworks, games, codex entries, sites, specimens, and more). It also clarifies that matching applies to names, old names, and one-line descriptions, which distinguishes it from the narrower search_artwork and search_codex 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?

'Use first when you don't know what kind of thing something is' gives a clear routing rule for when to prefer this over type-specific searches. It stops short of naming the sibling tools (search_artwork, search_codex, list_sites) that would be the alternatives once the type is known, so the guidance is clear but not fully explicit.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), so the description's contribution is the content restriction: this tool deliberately withholds the answer and later hints, which tells an agent not to press for more or treat a vague result as an error. It also discloses the dual mode (single hint vs. full title/site listing when id is omitted), which the annotations do not convey at all.

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 core behavior and the no-id listing mode are front-loaded in the first two clauses, and the restriction on later hints follows immediately. The 'slopped.site sites hide secrets' framing and the parenthetical about the codex ledger are flavor-heavy but do carry routing and scoping information, so almost every clause earns its place.

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

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

With one optional enum parameter, no output schema, and annotations already declaring the read-only/idempotent profile, the description needs to cover mode selection and content limits, and it does both. The one gap is the shape of an individual hint response, which is only loosely implied ('first, vaguest rung'), and there is no output schema to fill that in.

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% and the single id parameter is fully enumerated with its own description including the omit-to-list behavior, so the schema carries nearly all semantic weight. The description only adds that the omit case returns titles and sites, which is a modest increment over what the schema already states.

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 pairs a specific action with a specific artifact: it returns 'the first, vaguest rung of one secret's hint ladder,' and in listing mode 'every secret's title and site.' That is enough to distinguish it from get_codex_entry, which is named as the tool that reveals the later rungs, though the opening sentence about slopped.site hiding secrets adds atmosphere rather than precision.

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 trigger ('Use when someone is hunting and wants a nudge') and an explicit boundary ('never the answer or the later hints'), routing the agent to the codex's secrets ledger for anything beyond the first rung. There is no explicit when-not beyond that hint-ladder case, and neither tool is named exactly as a sibling (no 'get_codex_entry'), so the routing is conceptual rather than literal.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and non-destructive behavior. The description adds useful context beyond that: counts are anonymous, there are week and all-time windows, and the response includes names, ids, links and reasons or counts. It does not disclose rate limits or caching, but the important behavioral surface is covered.

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 dense sentence that front-loads the resource and the two modes. Parenthetical details are efficient, though the clause structure is slightly packed. Almost every phrase earns its place by distinguishing modes or listing return fields.

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 appropriately explains that results include names, ids, links, reasons or counts. For a four-parameter read-only list tool, this covers what an agent needs to call it, aside from explicit sibling differentiation and how 'section' applies per mode.

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%, with the 'list' and 'window' parameters already described in the schema. The description clarifies the meaning of both modes, including what picks contain and what most-saved counts represent, but adds little for 'limit' or for how 'section' interacts with 'list' and 'window'. Baseline 3 is appropriate when the schema does most of the parameter work.

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: 'Read top.slopped.site' and distinguishes two modes, curated picks and the most-saved board. It explains the content of each mode with concrete details like 'one-line reason' and 'counted anonymously'. It does not clearly differentiate from the sibling 'of_the_day', which likely overlaps with 'this week’s pick'.

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 usage context with quoted example questions: “what’s good here” or “what do people like”. It does not name alternatives or exclusions, such as when to use 'of_the_day' or 'list_sites' instead. Clear context but no sibling routing, 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?

Beyond the readOnly/idempotent/non-destructive annotations, the description adds meaningful behavior: it uses the same validator as the Game Builder and console (consistency guarantee), reports validity plus every problem with line and section plus contents, and confirms nothing is stored or played. That is exactly the kind of side-effect and return-shape context annotations cannot convey.

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 purpose is front-loaded and the paragraph flows from what it is, to when to use it, to what it returns. The three trailing URLs are somewhat heavy and the spec/docs pair is mildly redundant, but the parenthetical format summary is genuinely useful rather than filler.

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

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

With one required parameter, no output schema, and clear annotations, the description covers everything an agent needs: input format, validation semantics, return contents, and the absence of side effects. No significant gap remains.

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 already has a schema description, but the description adds format knowledge the schema lacks: meta lines followed by [palette] [sprite] [map] [sound] [music] [shader] [text] [game] sections. This helps the agent construct valid input, though it does not discuss the 65536 max length.

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 specific verb and resource ("Check a Slopbox cartridge") and even defines what a cartridge is, including its meta lines and section list. It is unambiguous about the operation, though it does not explicitly contrast itself with the sibling check_spec, leaving a small chance of confusion between two similarly named validation tools.

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

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

"Use when writing or fixing a cartridge before playing it" states a clear triggering context, and "nothing is stored or played" implicitly excludes using it as a play/execute step. There is no explicit when-not or named alternative, so it falls short of the top band.

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

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

Annotations already establish the safe read-only, idempotent, closed-world profile, and the description goes well beyond them by disclosing exactly what is validated (RS256 signature against the published key, issuer fields, dates) and what the response contains (earner, timestamp, evidence, game-run verification). This is the kind of behavioral detail annotations cannot express.

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 sentences, front-loaded with the core action and domain, then the accepted inputs, then scope. Dense but every clause carries information; the first sentence is long but not padded.

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 single-parameter verification tool, the description covers what is checked, what is returned, and the scope limit, which is sufficient even without an output schema. It does not say what happens on a failed or unverifiable badge, which is the one remaining 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% and the parameter description already enumerates all three accepted forms (compact JWS, credential URL, verify link). The description restates the same three formats and adds only the minor hint that the JWS may come "from a baked badge," so it contributes little 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 names a specific verb and resource ("Check an Open Badge issued by learn.slopped.site") and narrows the domain to Slop Curriculum and Slopbox game badges (cart-*). It does not explicitly contrast with siblings like validate_cartridge or check_spec, but the domain scoping is specific enough that an agent can tell what this tool covers.

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

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

"Use when someone shares a badge" gives a clear triggering condition, and "Only verifies learn.slopped.site badges" states an explicit exclusion. There is no mention of alternative tools for non-learn.slopped.site badges, so the routing is slightly incomplete.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the description correctly focuses on return behavior: the thing, its link, and every neighbour with edge type and direction. It also adds a genuinely non-obvious constraint that secrets are returned as titles only, which no annotation or schema conveys.

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 purpose and use cases, then id formats, then return shape, then the `to` option — a sensible order. The long enumeration of covered families partially duplicates the `type` enum in the schema and is the one place 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?

There is no output schema, and the description compensates by describing the return payload (node, link, neighbours, edge type and direction). It does not mention what happens when a name matches multiple nodes or how results are ordered/truncated when neighbours exceed the limit.

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% and both enums are documented in the schema, so the schema carries most of the parameter burden. The description adds marginal value by showing id format patterns and by naming representative edge types, but it does not explain how `type`/`edge_type` interact or how `limit` affects the path query.

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+resource ("Look up any thing in the slopped.site world by id or name") and immediately states the outcome ("see how it connects"). It enumerates covered entity families and gives concrete id examples ("game:spider", "codex:slopwright"), which clearly distinguishes it from siblings like search_world, get_codex_entry, or get_artwork that each cover one family.

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 query intents ("where does X appear", "what is connected to Y", "what is the page for Z") and explains that supplying `to` yields the shortest chain between two things. It does not explicitly say when to prefer search_world or the type-specific getters instead, so the sibling boundary is left partly to inference.

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