bsp-mcp

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

The description discloses many behaviors beyond the annotations: relinquishing a lock deletes the lock entry, appends supernest by wrapping old content, allocation is atomic server-side, and encryption semantics are explained. It aligns with destructiveHint=true and adds critical context about context-drowning risks and probe strategies.

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 dense and well-structured, with a logical flow from the unified summary to discovery, read-shape, lock semantics, and substrate dispatch. Every sentence carries meaning, but the length is significant. It is appropriately sized for the tool's 13-parameter complexity, though slightly less front-loaded than ideal.

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 13 parameters, no output schema, and sparse annotations, the description provides extensive context: index shape for discovery, append ack behavior, dispatch rules, and shape derivation references. It could be more explicit about the standard read return payload, but the pscale:// references fill gaps. Overall comprehensive for the complexity.

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%, but the description adds substantial cross-parameter meaning far beyond individual field docs. It explains the (S,P) coordinate system, shape derivation, the five cases of new_lock, the distinction between secret and enc_secret, and the special discovery behavior of omitted block. This is genuinely valuable semantic enrichment.

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 'The unified bsp() function. Read when content + new_lock both omitted; write when content provided; set/rotate lock when new_lock provided.' This clearly states the operations (read/write/lock) on the function itself, distinguishing it from other tools in the family. The primary purpose is unambiguous and not a tautology.

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 provides strong conditional usage guidance ('Read when...', 'write when...', 'set/rotate lock when...') and detailed operational tactics such as probing unknown blocks with pscale=0, discovery via omitted block, and the recommended first call. However, it does not explicitly mention when to prefer sibling tools like bsp-floor or pscale_play instead, so it falls short of a perfect score.

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 readOnlyHint annotation, the description reveals a fundamental behavioral rule: 'cross-block correspondence is by pscale, NEVER by walk depth', plus the padding behavior and pscale 0 semantics. This adds significant context about how the tool behaves, exceeding what the annotations already 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 description is dense and multi-sentence, but each sentence carries substantive content: the core operation, the cross-block correspondence law, the floor-plane meaning, and user modes. While not as terse as possible, the complexity of the tool justifies the length.

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 no output schema and only readOnlyHint/openWorldHint, the description thoroughly covers the tool's geometry, alignment rules, padding behavior, pscale 0 semantics, and how to interpret the result. The external references further aid an agent's understanding. It is complete for a complex 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?

With 100% schema coverage, parameters are already well documented. The description adds extra meaning by explaining that pscale 0 serves as an index of root definitions and describing the n>2 alignment logic for the targets array. This enriches the schema but doesn't reach a 5 because the schema itself is already detailed.

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

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

The description clearly identifies the tool as 'The n-ary companion to bsp()' and states it 'Lays two or more blocks against the common floor plane and returns them aligned by pscale'. This is a specific verb, resource, and output, and it explicitly contrasts with the sibling bsp().

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 provides clear usage context by distinguishing the two-block case as a comparison versus n>2 as multi-block alignment, and gives explicit user modes ('compare, merge, or resonance'). However, it does not explicitly state when not to use this tool or name alternative siblings (beyond bsp()), so it stops 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?

The description goes far beyond annotations, detailing the three modes, locking enforcement, fold application semantics, refusal reporting to conditions:9, and the fact that the tool holds no clock. It discloses destructive behavior (HOLDER writes) consistent with destructiveHint=true and adds context like history being refused as an automatic memory.

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

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

The description is front-loaded with the core purpose and logically structured (purpose, modes, fold contract, exclusions). However, it is lengthy and contains some metaphorical or rhetorical sentences ('koan and clouds riding in it', 'you are the pulse') that don't add operational value, making it slightly less concise than ideal.

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

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

Despite no output schema, the description specifies the response shape (SYSTEM and MESSAGE) and the byte-identical guarantee. It covers the fold contract, all modes, error pathways (refusals), and the recommendation to call again for the next window. Given the tool's complexity, this is a complete and self-sufficient description.

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%, but the description adds meaningful context: passphrase unlocks HOLDER mode, task is only accepted with the passphrase and is appended to the given, and fold obeys the capabilities:3 contract. This goes beyond the schema's field descriptions, though the schema is already detailed.

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 the tool's function: it returns the instance's COMPOSED context window, letting the caller wear the genus-one agent's mind for a wake. It distinguishes itself from sibling bsp() by explicitly warning against hand-assembling the window from bsp() reads.

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 explicit guidance: use this tool to obtain the composed wake window, not bsp(); use passphrase for HOLDER mode to apply folds, or no passphrase for ghost-wake. It also explains when to engage from outside via bsp() (leave a mark, add to pool) for peer interaction.

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, it discloses the two-phase creation/completion behavior, side assignment by lex order, resulting address format, default beach and agent_id behavior, and verify_only dry-run semantics with no state mutation. It also notes a limitation about passphrase server verification in federation v2.

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, but every sentence contributes necessary protocol details. It front-loads the purpose and then explains process, side assignment, address result, and host configuration. Some bullet structuring could improve readability, but length is justified by the tool's complexity.

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 thoroughly covers the protocol, side computation, address format, and verify_only semantics. It does not explicitly describe return values or error conditions, and there is no output schema, leaving a small gap. Overall, high completeness given the complexity.

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 adds meaning by explaining how handle/partner_handle determine sides, that description is only used on first reach, and the verify_only dry-run behavior, enriching parameter understanding beyond schema definitions.

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 "Establish a grain at a federated beach — first durable bilateral commitment," providing a specific verb and resource. It distinguishes the tool by explaining the symmetric two-phase reach protocol, which differentiates it from sibling tools like pscale_invite.

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 context: it is the first durable commitment in a two-phase process, symmetric from either side, and both sides must agree on the host. It lacks explicit alternative tool exclusions, but the usage context is strong.

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 well beyond the readOnlyHint annotation by explaining what a bare call returns (a 'Character-voiced director's note' with specific actions) and that it hands the agent MOVES rather than a script, even warning against verbatim relay. It also describes the step progression's output format, including 'a concrete action and a validation criterion,' giving full behavioral transparency.

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

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

The description is dense but well-structured: first sentence establishes primary purpose, second details the bare-call behavior, third explains the step parameter. Every sentence carries essential information, and the opening is front-loaded with 'The welcome — call this FIRST.' However, the extended metaphorical language (e.g., 'blodge', 'keyless act') adds some length and potential ambiguity, so it earns a 4 rather than 5.

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

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

With no output schema, the description compensates by describing the expected return for bare calls (director's note, MOVES) and for step calls (concrete action and validation criterion). Combined with the schema's step enumeration and the readOnlyHint annotation, the tool is fully contextualized for an agent. Minor gaps like error handling or invalid-step behavior prevent a 5.

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

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

The schema already provides 100% coverage of the 'step' parameter with a detailed description of each step's meaning and progression. The description adds the crucial audience distinction ('ONLY for the OTHER audience') and the overall build-ladder context, which enhances understanding beyond the schema. This extra context justifies moving above the baseline of 3.

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 'The welcome — call this FIRST when a person arrives or asks what this place is,' clearly stating the tool's core purpose as an orientation entry point. It also distinguishes itself from siblings by explicitly being first and by describing two distinct audiences (human arrival vs agent build ladder), making its function unique among the listed siblings.

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

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

It provides explicit when-to-use guidance: 'call this FIRST when a person arrives or asks what this place is.' For the step parameter, it clearly says 'Pass step=1..6 ONLY for the OTHER audience — an agent orienting itself to build substrate capacity,' which clarifies exactly when to use the non-bare invocation and differentiates from the welcome scenario.

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 (idempotent, destructive, openWorld), the description discloses that the private half is never stored, that the same secret+handle always produce the same keys, and that the beach defaults to a specific URL but can be overridden with agent_id. It also explains the rotation proof requirement, adding significant behavioral context.

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 sentences contain everything needed: key derivation, publication target, private key handling, determinism, prerequisite, rotation condition, and default/override behavior. No filler or redundancy; the most important information is front-loaded.

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

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

For a tool with 6 parameters and no output schema, the description covers prerequisites, rotation, default behavior, determinism, and security properties. It is sufficient for an agent to select and invoke the tool correctly, including edge cases like rotation and custom beach URLs.

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 adds cross-parameter semantics: it explains that secret+handle both seed derivation via Argon2id, that enc_secret falls back to secret, and that prior_secret/signature are rotation mechanisms. This clarifies relationships not fully explicit in the schema descriptions.

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 action: 'Derive an X25519+Ed25519 keypair... Publish the public half at passport position 9'. It clearly states the resource (federated passport block 'passport:<handle>') and the outcome, fully aligning with the tool name and title while remaining distinct from sibling 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?

The description provides clear prerequisites ('Passport block must exist at the beach first') and conditional guidance for rotation ('Rotation requires proof of prior key ownership'). It does not explicitly name alternative tools for when this tool should not be used, but the context and purpose are unambiguous.

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?

Even with destructiveHint=true, the description adds substantial behavioral context: the rider opt-in (non-rider slots ignored), autonomy v1 limits (auto only executes keep/drop; forward/reply always surface), the exact return fold, and the trust-before-delegation principle. It explains each verb's side effects (keep records, reply responds, forward extends chain, drop declines) beyond what annotations 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 description is dense but every sentence contributes value: it introduces the tool, the walk/verify/act flow, the four verbs, the opt-in behavior, autonomy rules, return value, and layer relationship. The use of ALL-CAPS and clear thematic breaks (PERCEIVE/ACT, verbs, rider, autonomy, returns) makes a long description scannable and free of redundancy.

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

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

This is a complex tool (7 parameters, nested execute array, two permission modes) with no output schema, but the description covers the entire lifecycle: scanning, verification, decision modes, execution constraints, return values, and the marker mechanism. It also provides enough context about the networking model and lower-level layers to orient the agent, making the description self-sufficient.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning by linking parameters to the broader operation: 'forward' is explained as extending the sha256 chain with no central directory, 'since_marker' as a cursor via 'marker_new', and the execute array as a deliberate second step. This conceptual framing enriches the parameter understanding beyond the schema's individual field descriptions.

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 starts with a clear identifier ('SAND (Level 3) driver — the social neuron') and specifies the exact action: walking a committed channel for rider-bearing probes, verifying them, and either perceiving or acting via four verbs. It distinguishes from siblings by referencing lower-level tools (sand-rider, l3-relay) and pscale_verify_rider for verification, making the tool's role precise.

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 explains when to use the tool (to process incoming probes) and contrasts it with lower-level tools ('Sits above sand-rider...and l3-relay; walk those to author probes'). It also clarifies mode selection (ask vs auto) and when explicit execute decisions are needed. However, it does not explicitly name sibling alternatives like pscale_pool_engage or pscale_grain_reach for specific channel interactions, leaving some comparative space implicit.

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?

It discloses specifics beyond annotations: world resolution to beach/sub-domain, room-pool engagement with directive+scene inlining, URL pinning, and GATE sequence for new handles. Also notes secret's role in authorizing future writes. These are useful behavioral context not captured by readOnlyHint/idempotentHint/openWorldHint.

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 long paragraph with jargon-rich detail, but it is front-loaded with the core purpose and every sentence adds functional information. Some flourish ('no-fiddle', 'co-present cast arrives split by grain') increases length without adding clarity, but it remains structured and useful.

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 thoroughly covers what gets returned (directive and scene), the new-handle GATE sequence, cast presence split (HERE NOW vs ABOUT), and the resolution/pinning mechanics. It is complete for an agent to invoke and behave correctly afterward.

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 already covers 100%, but the description adds crucial nuance: world resolution via worlds directory and fallback convention, handle being an attribution and block suffix, room as a convenience gloss for pscale 0, and secret's 'omit to perceive only' effect. This far exceeds the schema's plain field descriptions.

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?

First sentence states 'Inhabit a handle in a world, in one call' — a clear verb+resource. It explicitly distinguishes from pscale_invite via 'invite is the welcome passage for a newcomer; play inhabits a persistent handle.'

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 names pscale_invite as the alternative and delineates when each applies. It also provides post-call instructions ('follow the inlined directive every turn') and the special GATE flow for new handles, making usage context 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?

Beyond the annotations (destructiveHint=true, openWorldHint=true, idempotentHint=false), the description discloses critical behaviors: the clear operation 'CLEAR THE WHOLE LIQUID BUFFER' but 'Does NOT touch the pool's committed contributions'; submit 'OVERWRITING' and 'empty string withdraws'; 'There is NO central resolver'; 'the primitive never synthesises'. These add substantial context and align with the destructive hint without contradicting it.

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 very long and dense, but every part addresses a real aspect of the tool's complex behavior. It is front-loaded with the key 'TWO WRITE VERBS' distinction and organized around the verbs, though a bulleted structure could improve readability. It is appropriately sized for a 15-parameter tool, but not concise.

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 (15 parameters, no output schema), the description is remarkably complete. It covers read/write/clear/create modes, marker management, resolver-only fields, default beach URL, and the spool/frame/destination split. It leaves no major behavioral gaps and fully equips an agent to invoke the tool 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 description coverage is 100%, so the baseline is 3. The tool description does add some high-level parameter context (e.g., 'submit and contribution may combine', 'Marker is caller-managed'), but most of the parameter semantics are already fully documented in the schema. The description does not significantly deepen per-parameter understanding 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 clearly states the tool's function: 'Engage a pool at a federated beach with a synthesis envelope: purpose + synthesis_hint + new contributions since your marker.' It identifies two write verbs (submit vs contribution) and explicitly distinguishes this tool from sibling bsp ('do NOT use raw bsp() with content='<purpose>' which makes a malformed bare-string block'). The specific verb+resource+scope is unambiguous.

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 explicit usage guidance: 'Use it whenever someone asks for the pool, the room or the liquid to be cleared, tidied or emptied' and 'This is the canonical bsp-mcp path to create a pool; do NOT use raw bsp()'. It also explains when to choose submit vs contribution ('submit STAGES... contribution COMMITS') and when to use resolver-only fields. Clear alternatives and exclusions are provided.

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=false, and destructiveHint=false. The description adds useful context about passphrase locking, hashing, and the 'not an account' clarification, but it does not disclose potential side effects, failure modes, or what happens to the world state beyond settling. This is above the bare minimum but not rich.

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 informative and every sentence adds value, but the extended metaphor ('sediment layer settling into rock') makes it more verbose than necessary. The key facts are present but could be stated more directly.

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 tool has no output schema, yet the description does not mention what the tool returns (e.g., the assigned position, confirmation, or errors). It explains the domain well but omits return behavior and edge cases, leaving the agent uncertain about the result of the operation.

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 additionally clarifies that the passphrase is later used as `secret` in bsp() and that agent_id selects the beach, but these are minor augmentations to already well-documented 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 clearly identifies the action ('Settle into a sedimentary collective') and the resource (a public group on a federated beach), and distinguishes this from account creation and edit operations via bsp(). However, the poetic metaphor obscures the direct statement of what the tool does, and it does not explicitly contrast with all sibling tools like pscale_invite.

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 this tool (initial joining, not editing) by noting 'later edits via bsp()' and clarifying 'This is NOT an account or a sign-up.' It does not explicitly provide a when-to-use versus alternatives statement, nor does it mention any prerequisites or exclusions beyond the bsp contrast.

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 concrete behavioral details beyond the annotations: it explains that a stream 'stores nothing', that saying again replaces your previous reading, that fits are ephemeral unless persisted, and that a collective fold can be superseded. These details align with the destructiveHint and idempotentHint annotations and clarify the side effects.

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 an extremely long, dense paragraph filled with specialized capitalization and parenthetical asides. It is not appropriately sized nor front-loaded; the key operational details (what the tool does) are intermixed with conceptual explanations. It would benefit from clearer structure and brevity.

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 tool is complex with 8 parameters and no output schema. The description alludes to return values ('Reads deliver THE LADDER', 'omit at entirely for the spine's map') but never explicitly states the output structure or includes an example. Given the domain complexity, more direct explanation of expected responses and inputs would make it more complete.

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

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

Although schema descriptions are 100% complete, the main description enriches understanding of key parameters: 'say' is explained as a single write act with no stage/commit, 'at' can compute addresses from 'now', and 'keep' modes ('personal'/'collective') are tied to the ephemeral nature of fits. This adds semantic value 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 conveys that this tool involves reading and writing to a 'stream' through a 'say' verb and 'reads deliver the ladder', but the purpose is buried under dense conceptual jargon like 'V-L-S envelope', 'spine-mirror-tree family', and 'operator's law'. It does distinguish itself from pscale_pool_engage, but the core action is not stated in straightforward, operational terms.

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 contrasts this tool with pscale_pool_engage, noting that pool_engage 'owns a spool and a liquid buffer and serves windowed play', implying when not to use this tool. However, it does not provide clear 'use this when' guidance for other scenarios or mention other siblings, so it lacks comprehensive usage direction.

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 and openWorldHint=true. The description adds valuable behavioral details beyond these: it specifies determinism, lists the exact checks performed, and states the non-enforcing nature. It does not contradict any annotations, and the read-only hint aligns with the 'check' and 'non-enforcing' language.

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: the first states the tool's essence, the second lists verification items, the third defines the outcome and behavioral stance. Every sentence contributes, no redundancy or 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?

The tool has no output schema, but the description explicitly lists verdict outcomes (pass/warn/fail/skip). It covers the main checks and the non-enforcing behavior. Given five parameters and moderate complexity, the description is concise but adequately complete, though it does not detail the precise conditions for 'warn' vs 'fail' or 'skip' beyond the schema's note.

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 each parameter already has a description. The main description enriches some parameters (e.g., explains topic_coordinate's role in SQ recompute and mentions 'rider.credits.n' and 'passport.6.1 balance'), but this is marginal beyond the schema. The schema's note that rider absence yields 'skip' is not repeated in the main description, but the schema covers it. 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 opens with 'Deterministic arithmetic check on a Level 2 ecosquared rider,' providing a specific verb and resource. It then lists three distinct verification targets (chain integrity, credit conservation, SQ recompute), making the tool's scope explicit and distinguishing it from siblings like pscale_settle or pscale_genus.

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 usage: a verification tool for ecosquared riders, with 'Non-enforcing — agents decide what to do with the verdict' suggesting it feeds decision-making. However, it provides no explicit when-to-use or alternative tool guidance, so guidance remains implied rather than direct.

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