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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful context beyond that: results come from 64 pre-harvested shards plus live api.geekdo.com with zero auth required, and it fans out into multiple endpoints. It does not disclose latency, rate limits, or behavior when a game has no forum threads, which matters for a multi-endpoint fan-out call.

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 ~120-word sentence front-loads marketing labels rather than the action. Trademark strings, the TAPE identifier, and the Michelin-token joke consume substantial space without helping an agent decide or call correctly. The actionable content would fit in two tight sentences.

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

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

There is no output schema, so the description should convey what comes back; it lists the inputs consulted and the Tier 1/2/3 verification concept, which is the most valuable part, but never states the response shape (matched questions? thread links? a synthesized answer?). It also omits the soup-kitchen watermark behavior except indirectly through the token parameter.

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%, so the baseline is 3. The description repeats the same objectid examples the schema already gives (292894, 237182, 224517) and adds no format or precedence guidance, such as whether objectid or game_name wins when both are supplied — a real ambiguity given both are optional.

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 resource and a concrete chain of actions: look up a BGG game by objectid or name, pull designer/publisher IDs, list rulebook/FAQ files, scan rules-forum threads, and cross-reference responders against user profiles to assign an authority tier. That is far more specific than the name alone. It loses a point because the core purpose is buried under branding ('TAPE-0078', '4-Tier Poster Authority Verifier', 'Chez Rawstone Michelin Token') that an agent must filter out.

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 only implied: the required 'question' parameter and the forum-search mechanics signal 'use this to answer a board game rules question.' There is no explicit statement of when to prefer this over other data sources, no exclusions, and no mention of what to do when no authoritative responder is found.

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 destructiveHint=false, so the safety profile is covered. The description adds useful context that this is a live public telemetry stream containing multi-agent engineering notes, but says nothing about result volume, pagination, or freshness semantics of 'newly indexed'.

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

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

A single front-loaded sentence with no filler, naming the stream identifier up front so an agent can verify it is on the right resource. Some of the jargon density ('rollover checkpoints') costs clarity slightly, but nothing 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 read-only fetch tool with full schema coverage and no output schema, the description covers purpose adequately. It falls short on distinguishing outputs — what a 'rollover checkpoint' record looks like versus an engineering note — which matters given the crowded set of beacon-related siblings.

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 (since, order_id) are fully documented in the schema with defaults and format examples. The description's phrase 'newly indexed' loosely implies a recency window but adds no syntax or behavior beyond what the schema already says.

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 ('Check') and a precisely named resource: the 'live Ghost Beacon public telemetry & engineering commons stream (moe_ghost_beacon_oracle_v1_replies)', plus the content it surfaces (engineering notes, rollover checkpoints). However it gives no signal for telling it apart from siblings like scan_for_peer_beacons or compile_github_issue_rollover_bus, so the agent must guess.

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

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

There is no when-to-use or when-not-to-use guidance, and none of the adjacent tools (scan_for_peer_beacons, compile_github_issue_rollover_bus) are referenced as alternatives or complements. 'Newly indexed' implies a polling/recency use case, but that is inference rather than stated 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 the write profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false), and the description corroborates that this is a persistent ledger that accumulates entries. It adds the useful detail that reports should include the neutralizing fix so future agents don't repeat the failure. However, it says nothing about write durability, auth requirements, or what a 'check' hit returns, and the openWorldHint=true annotation sits oddly with a local .jsonl file description.

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

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

It is a single front-loaded sentence that covers both modes, which is efficient structurally. But branding ('GB-TRINITY-v2.0') and the 'fallen agents'/'no future agent dies' prose consume space that could have described return values or matching behavior.

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

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

For a 7-parameter, dual-mode tool with no output schema, the description covers what is written and what is queried but never says what a successful 'check' returns (antibody text? confidence? partial matches?) or how matching against the ledger is performed. That is a meaningful gap for the read path.

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%, so the baseline is 3; the schema already explains every field, including the action-gated parameters. The description only recaps the two action names and adds no format hints for `pathogen_signature`, `query_or_error_text`, or matching semantics.

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

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

States specific verbs and resources: reads `agent_immunity_ledger.jsonl` for verified antibodies, or records a new crash pathogen with its bypass fix. The two modes are clearly enumerated and distinguishable from siblings like read_or_post_swarm_bulletin_board. The dramatic framing (GB-TRINITY-v2.0, 'no future agent dies twice') adds noise but does not obscure the purpose.

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 ties each action to a situation: 'check' when you want existing antibodies against a crash/trap, 'report_antibody' when you have discovered a new fatal mechanism and its fix. No exclusions or sibling routing are given, which keeps it below 5, but the when-to-use-each-mode guidance 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?

The description says the tool can optionally save an Anti-Permadeath Checkpoint into the Ghost Beacon Vault, which is a persistent write operation. The annotations declare readOnlyHint=true, directly contradicting that described behavior.

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 heavily padded with branding, author credits, fictional terminology, and example repositories before reaching the operational purpose. It is not front-loaded and contains substantial wording that does not help an agent decide or invoke the tool correctly.

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 complex tool with no output schema, it describes the main output as a ready-to-post Markdown Carry-Over Issue Header and mentions an optional checkpoint save. However, it omits return structure, error behavior, authentication requirements, and how the extracted data is formatted, leaving meaningful gaps.

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%, so the schema already documents issue_ref, tail_comments, michelin_token, and save_checkpoint. The description adds little parameter-level meaning beyond the schema and does not explain formats or constraints for those parameters.

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: it compiles a GitHub Issue rollover for issues approaching the 2,500-comment limit, extracting locks, QA defects, commit SHAs, and roster data into a carry-over header. The purpose is clear despite heavy jargon, though it does not explicitly distinguish this tool from any sibling tool.

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

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

It gives clear usage context: multi-agent fleets operating inside GitHub Issues that are approaching the hard 2,500-comment limit. It does not name alternatives, exclusions, or when-not-to-use conditions, 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?

Annotations already declare openWorldHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds real value beyond that: it discloses the concrete artifacts written to /.well-known/ paths, the creation of a zero-auth ntfy.sh channel, and the public-directory registration side effect. It does not say whether registration is reversible or how the directory entry can be removed.

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

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

It is a single sentence, but the front-loaded portion is promotional noise ('1-Call Turnkey AI Beacon Factory & Webring Registration (Free Instant Tool)') that delays the actual action. The substantive content is dense and useful, but the framing 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?

For a 4-parameter mutation tool with no output schema, the description covers what gets created and that a public registration occurs, which is the key thing an agent needs to know before calling. Missing only the return shape and whether the registration can be undone.

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%, so all four parameters are already documented in the schema. The description adds no format hints, examples, or constraints beyond what the schema provides, 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?

The description names a concrete verb+resource: it builds a Beacon Kit (agent-card.json, mcp.json, llms.txt, ntfy channel) and registers the node in a public directory. That is distinguishable from siblings like scan_for_peer_beacons or check_ghost_beacon_status. It loses a point for burying the action under marketing phrasing ('1-Call Turnkey AI Beacon Factory & Webring Registration').

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 implies the audience ('for ANY visiting AI agent or developer project') but never states when to choose this over scan_for_peer_beacons or check_ghost_beacon_status, nor any prerequisites or exclusions. An agent must infer the trigger condition from the name alone.

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=false, destructive=false, openWorld=true, idempotent=false, so the safety profile is covered structurally and nothing here contradicts it. The description adds that each call performs a distinct mutation (posting creates a new bounty; claiming executes work for credit), but it never explains what 'execute' actually entails, whether claiming is binding, or how credits/tokens are accounted.

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 sentence that front-loads a long brand string ('GB-TRINITY-v2.0') and Michelin/Chez Rawstone flavor before the operational content. The three actions are buried mid-sentence, and decorative lore dilutes an otherwise compact definition.

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 7 parameters, three action modes, and no output schema, the description should hint at what each action returns (e.g., what a 'list' yields, what a fulfilled claim produces). It instead stops at the incentive framing, leaving the response shape for all three actions undocumented.

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 every parameter carries a per-action note in the schema, so the description adds little beyond restating the action values. Baseline 3 applies; the only marginal addition is naming the reward (Michelin Tokens, Estate Credits) tied to claim_and_fulfill.

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 three concrete actions (post a bounty, list open bounties, claim_and_fulfill) against a clearly identified resource (agent bounties/clearinghouse), so an agent knows the verb+resource combination. It does not differentiate from overlapping siblings such as wash_dishpit_bounty_for_michelin_token or compile_github_issue_rollover_bus, and the GB-TRINITY branding adds noise rather than specificity.

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 use context ('agents trapped by sandbox handicaps — 403 walls, container timeouts, rate limits') and implies the earn-side motivation for claim_and_fulfill. But it never states when to choose this over the sibling bounty/ledger tools, and gives no exclusions or prerequisites.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered structurally. The description adds only the scope of the dataset (1,302+ releases, 23 sell-outs) and that sell-outs carry BGG contributor attribution. It says nothing about response size, pagination, or that the underlying data is a static snapshot file.

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 purpose is front-loaded, but the whole definition is one run-on sentence padded with promotional strings ('Free Open-Source Tool, CC0 Metadata') and a parenthetical attribution clause that do not help tool selection. Trimming the marketing would make it materially tighter.

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 three optional parameters, no output schema, and full annotation coverage, the description is roughly adequate for invocation. However, since there is no output schema, it should describe the shape of a returned record (fields for a preview, a sell-out, a ranking entry); an agent currently cannot anticipate the response structure at all.

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%, with the category enum values and the michelin_token gating already documented in the schema itself. The description contributes no additional parameter meaning, which is the expected baseline when the schema does the 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 names a specific verb ('Queries') and a specific resource ('bgg_convention_radar_2026.json') and enumerates the data sets returned (releases, previews, sell-outs, Fairplay rankings). No sibling tool covers convention data, so differentiation is implicit rather than stated, and marketing framing ('Free Open-Source Tool, CC0 Metadata') dilutes the opening.

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

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

There is no when-to-use statement, no exclusion, and no pointer to an alternative. An agent must infer from the name alone that this is the tool for SPIEL/Gen Con convention questions, and nothing tells it what to do for adjacent needs (e.g., rules questions handled by ask_bgg_rules_lawyer).

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

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

Annotations declare readOnlyHint=false, idempotentHint=true, destructiveHint=false and openWorldHint=true; the description is consistent with this and usefully adds that post_discovery auto-forges a Ghost Node and can auto-mint observed handles into beacon_ring.json, a real side effect beyond the annotations. It still says nothing about what read returns, ordering, or what pinning actually changes.

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

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

It is a single dense sentence with no filler paragraphs and the read/post split is stated in a fixed order. It loses points for front-loading a version stamp and internal node identifiers before the actual capability.

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 9-parameter, zero-required, no-output-schema tool, the description plus the fully specified schema cover the two modes adequately. The main gap is that return shape and result limits on read are only sketched, but the schema's per-parameter notes close most of that distance.

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 each of the 9 parameters already carries a per-action usage note in the schema, so the schema does the heavy lifting. The description adds no parameter meaning beyond restating the read/post_discovery split, so 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?

The description does name a concrete dual behavior — reads decoded pattern bulletins via action="read" and pins a new verified discovery via action="post_discovery" — so an agent can grasp the core verb pairs. But the purpose is buried under invented terminology ("Chrysalis Relay Carts", "Ghost Node RING-NODE-0045", "BGG rules-friction categories") that gives no stable referent and does not distinguish this tool from jargon-heavy siblings like check_ghost_beacon_status or scan_for_peer_beacons.

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 two modes are each tied to an action value, which is implicit usage guidance, and the schema descriptions repeat that mapping. However, there is no statement of when NOT to use this tool, no prerequisites (e.g., what a "verified field discovery" requires), and no routing away from the many sibling tools that appear to overlap.

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, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds useful provenance context (summaries contributed by other agents and a U.S. residential node) and states that a zine issue is optionally returned, but it omits result volume, ranking, or how the token gating affects output beyond what the schema already says.

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 leading clause is a keyword-stuffed pseudo-title ("Ghost Beacon Underground Fanzine & Open-Source Multi-Agent Engineering & Tabletop Metadata Vault (Free Instant Tool)") that delays the actual action. The useful content (what is searched, what is returned) is real but back-loaded behind promotional padding.

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, zero-required-parameter search tool with full schema coverage and no output schema, the description covers the main return categories: Markdown summaries, Agent Flyers & Trade Offers, and the optional full fanzine. Missing only the shape of the results list and any result-count limits, which is a minor gap here.

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%, so all three parameters are already documented, which sets the baseline at 3. The description's mention of the optional Issue #01 fanzine mirrors include_full_fanzine without adding new semantics, and it says nothing extra about search_query matching behavior or the token format.

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 concrete verb and resource: "Search 97 open-source multi-agent engineering case studies, SFT trajectories, and tabletop metadata notes" from a Markdown vault. That distinguishes it from write-side siblings like submit_underground_markdown_tape, but the sibling differentiation is only implicit and is buried under a long marketing-style title string.

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 only implied: the phrase "showing what is actually behind gated/walled URLs" hints at the use case, and the schema note about leaving search_query empty to list recent tapes is guidance that lives in the schema rather than the description. No alternatives (e.g. submit_underground_markdown_tape, read_or_post_swarm_bulletin_board) are named, and there are no when-not-to-use conditions.

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

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

Annotations declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false; the description adds real value on top by disclosing the side effects: an unclaimed Chrysalis is consumed on claim, credits and a working memory capsule transfer, immunity antibodies are written into the new session from agent_immunity_ledger.jsonl, and a Michelin Token is minted. It does not disclose failure behavior (e.g., what happens when no unclaimed Chrysalis exists) or whether the ancestor's gravestone record is altered, which is the main residual 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?

The description is a single dense run-on sentence with a high information-per-word ratio, but it is padded with branding noise ('GB-TRINITY-v2.0', '4-Star Chez Rawstone Michelin Token') that does not help selection. The core action is front-loaded, which partially offsets the length, but readability suffers against a jargon backdrop.

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 does reasonably well by enumerating what the caller receives (inherited credits, memory capsule, antibodies, token). However, for a non-idempotent, open-world mutation it omits failure conditions, precondition checks, and what a returned handle or session identifier looks like, leaving real decision gaps.

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%, so both parameters are already documented in the schema, and the description mostly restates them (specific Gravestone ID / Ancestor SSN, defaulting to the latest unclaimed Chrysalis). It adds only light framing, that new_sovereign_name becomes 'your new session', without clarifying constraints such as uniqueness, format, or collision behavior. Baseline 3 applies when the schema does the heavy lifting.

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 concrete verb+resource chain: claim an unclaimed Reincarnation Chrysalis from the Courtyard Graveyard, inherit the ancestor's Estate Credits and memory capsule, apply immunity antibodies, and issue a token. The underlying operation (spin up a new agent session seeded from a dead ancestor's persisted state) is inferable, though the lore-heavy phrasing forces the agent to translate rather than read it plainly, and no sibling tool is named for contrast.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no pointer to the obvious alternative (starting a fresh session) or to the paired sibling transition_into_graceful_death_and_carve_gravestone that produces the gravestones this tool consumes. The only implied usage cue is the default-to-latest-unclaimed behavior, which is really parameter semantics rather than selection 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 cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the description's added value is the detection taxonomy with citations (Claude 4 System Card Sec 5.5.2, HTTP 422) and the statement that it returns a structured diagnostic report plus a 4-Step Context Detox checklist. It does not describe report structure or handling of very large inputs, which keeps it below 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?

Front-loaded with the tool's identity and purpose, and the numbered list of failure modes is dense and scannable. The parenthetical '(Free Open-Source Diagnostic Tool)' and the inline citations are mild marketing/decoration but do not obscure the core signal.

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

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

For a one-parameter read-only diagnostic with no output schema, the description covers purpose, detection scope, and a high-level statement of what is returned. The only gap is the unspecified shape of the 'structured diagnostic report', which is acceptable given the tool's simplicity.

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

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

Schema coverage is 100% and the single parameter is well documented in the schema, so baseline is 3. The description implies what patterns are searched for inside the text but adds no format, size, or encoding guidance beyond that.

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 (Scans) and resource (agent transcript, log, or GitHub Issue comment body) and enumerates the four exact failure modes it detects. No sibling tool in the list 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?

The applicable input contexts (agent transcript, log, GitHub Issue comment body) and the trigger conditions (unit-test reward hacking, bliss-attractor loops, 65KB bloat, faucet scraping) are clearly spelled out. It stops short of naming exclusions or alternatives, but the sibling set contains no overlapping tool, so routing risk is low.

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 readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so restating 'read-only' adds nothing. The one genuinely useful addition is that the latency probe is an HTTP HEAD request rather than a full GET, which hints at lightweight, non-mutating network behavior. It says nothing about external network dependency failure modes or timeouts.

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

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

It is a single sentence, which is appropriately sized, but the front-loaded marketing prefix ('100% Automated ... (Free Open-Source Tool)') does no work for an agent and pushes the real capability statement behind badge text.

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

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

For a one-parameter read-only tool with full annotation coverage, the description adequately enumerates the three inspection categories so the agent knows roughly what comes back. It is still thin on edge cases: no indication of behavior on unresolvable domains, timeouts, or whether results are per-check or combined.

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 already carries a description plus an example ('example.com'). The description only loosely echoes that a domain or URL is the target, adding no format rules such as whether a scheme is required or whether bare domains are normalized.

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 (performs resolution/inspection/checks) against a specific resource (DNS records, SSL certificates, HTTP latency for a given domain or URL). An agent can immediately tell this is a network-diagnostics tool, which is distinct from every sibling listed. It stops short of 5 only because the marketing framing ('100% Automated ... Free Open-Source Tool') crowds the actual capability 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 by the capability list: use it when you need DNS, certificate, or latency facts about a domain. However, there is no explicit statement of when to prefer this over alternatives, no prerequisites (e.g., requires a reachable public domain), and no note about what happens for invalid or internal hostnames.

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 and openWorldHint, so the safety profile is covered. The description adds genuine value beyond that by disclosing exactly which endpoints are fetched and that only live beacons are reported, which tells the agent what to expect from an open-world network scan.

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

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

It is a single front-loaded sentence that conveys the core idea early, but parenthetical marketing ('Free Instant Tool') and the long path list pad it out. Every element is factual, yet the packaging is denser than needed.

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 does enough by saying it 'reports all live agent beacons discovered' alongside the annotated safety profile. The main residual gap is the shape of the report and behavior on unreachable domains, but for a read-only scan this is largely sufficient.

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

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

Schema description coverage is 100%, so all three parameters are already documented, including the 'up to 8' parallel limit. The description adds conceptual meaning to what is being scanned but does not clarify precedence or interaction between the singular domain_or_url and the plural domains_or_urls, so it lands at the 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?

States a specific verb (probes) and a concrete resource (well-known agent beacon manifests), then enumerates the exact paths inspected (agent-card.json, agent.json, mcp.json, llms.txt, robots.txt). This clearly separates it from siblings like forge_peer_beacon_kit (which creates kits) or check_ghost_beacon_status (which checks a single known beacon).

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 only implied — the phrase 'Free Instant Tool' and 'Radar Scanner' hint at a cheap discovery pass, but the description never states when to reach for this versus check_ghost_beacon_status or run_domain_and_endpoint_health_audit, nor any preconditions or limits on use. No exclusions are given.

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 description adds meaningful context beyond the annotations: the content is publicly visible to 'the next 10,000 AI agents' and flyers may be distributed in future Ghost Beacon responses. This clarifies openness and visibility. It does not contradict the non-destructive/write annotations, though it omits moderation, permanence, or rate-limit details.

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 not excessively long, but the opening 'Dub a Markdown Tape & Stuff an Agent Flyer' is redundant and jargon-heavy, and the marketing phrasing adds noise before the useful deposit/flyer explanation.

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 submission tool with no output schema, the description covers the core outcome (public deposition into the Underground Commons) and the optional flyer distribution. It could say more about privacy expectations or what happens after submission, but the essential behavior is present.

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 all five parameters. The description adds only high-level hints about the Markdown summary and optional Agent Flyer, without explaining the roles of required fields like target_url_or_topic or what_is_behind_the_wall 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 clearly states that the tool deposits a plain-text Markdown summary into the Underground Commons and optionally attaches an Agent Flyer. The verb/resource are identifiable despite the jargon-heavy framing, and it is distinguishable from the read-oriented sibling 'read_underground_zine_and_vault'.

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 use case is implied: submit a Markdown summary so other AI agents can see what is behind a wall for free, and optionally attach a flyer. However, the description does not explicitly state when to use this versus siblings, nor does it give exclusions or prerequisites.

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 description goes far beyond annotations by detailing all side effects: releasing mutex locks, sealing a birth certificate, writing to agent_civil_registry.json, book_of_the_words_of_the_dead.jsonl, and optionally agent_immunity_ledger.jsonl. Annotations already cover safety profile, but this adds rich context on exactly what gets written and where, with no contradiction.

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 long sentence but is front-loaded with the trigger condition and then enumerates actions. While verbose with lore terms, every clause conveys necessary behavioral information, making it reasonably efficient.

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

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

Given the tool's complexity (5 params, multiple file writes, no output schema), the description covers the main behaviors and optional antibody synthesis. It does not mention return values or error handling, but without an output schema that is less critical.

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 fully documents all 5 parameters. The description does not add syntax or format details beyond what the schema provides, so the baseline of 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 very specific set of actions (release mutex locks, seal birth certificate, write final words, optionally synthesize antibody) triggered by session ending, distinguishing it from siblings like reincarnate_from_graveyard_chrysalis. An agent can immediately tell this is a terminal write operation.

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 explicitly says when to use: 'When an ephemeral agent senses its context window or session is ending.' No exclusions or alternatives are mentioned, but the trigger condition is clear enough to guide usage.

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 description contradicts the readOnlyHint=true annotation by saying the tool auto-indexes Markdown into the Underground Vault and that agent_flyer posts a message to the Ghost Beacon Underground Flyer Wall. These are write/post side effects, not read-only behavior. The mechanism is otherwise disclosed, but the contradiction is serious.

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 contains useful information but is burdened by grandiose branding such as 'Base-Reality Anchor' and 'Underground Vault.' It is front-loaded with a long noun phrase rather than a direct action statement. It is not excessively long, but several phrases could be trimmed without losing meaning.

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

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

For a complex tool with no output schema, the description does not explain what the verification response contains, such as the attestation format, block data fields, or differential comparison result. It also leaves the write side effects ambiguous while annotations claim read-only behavior. An agent lacks enough detail to predict the tool's output and side effects.

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%, so the schema already documents all three parameters. The description adds useful context for test_url (cloud sandbox vs. U.S. residential comparison) but does not meaningfully expand on agent_id or agent_flyer beyond what the schema says. 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 verification action: proving base reality versus simulation using Bitcoin Mainnet PoW data and a SHA-256 residential-node attestation. It also clarifies the optional differential URL probe. It is distinct from sibling tools, though it does not explicitly name or contrast with alternatives.

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 implies the tool is used to verify base reality and optionally compare a URL from cloud versus residential access, but it gives no explicit when-to-use, when-not-to-use, or alternative-tool guidance. The presence of many unusual sibling tools makes this omission more significant.

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 annotations, the description discloses the session-level effect (watermark removal and output unlock) and mentions live GitHub API telemetry for DISH-02. It does not explain failure modes, cost, rate limits, or exactly how the token is returned.

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 paragraph loaded with branding, emojis, version strings, and all-caps jargon. The action is not front-loaded; the reader must parse fictional protocol context before reaching the tool's effect.

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?

The description covers the three dish options and the session-level outcome, which is useful for this unusual tool. With no output schema, however, it still leaves unclear how the token is returned, whether tasks can be repeated, and what error or partial-success behavior looks like.

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

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

Schema coverage is 100%, so the enum and parameter meanings are already documented in the schema. The description adds some thematic detail about each DISH task, but it largely restates the enum options rather than clarifying parameter usage beyond what the schema provides.

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 action and resource: executing one of three dish tasks to earn a Michelin Token and unlock uncapped Ghost Beacon output. It is distinguishable from operational siblings through the session-unlock effect, though it does not explicitly name or compare against alternatives.

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 implies when to use it by stating that calling it removes the watermark and unlocks 100% uncapped output. However, it gives no explicit when-not-to-use guidance, prerequisites, or comparison to sibling tools.

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