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

With no annotations, the description carries the full burden, and it does disclose a genuine behavioral trait: the server validates the message exactly as it validates a browser player, which tells the agent to expect authoritative rejection rather than client-side trust. It omits connection prerequisites, what happens on validation failure, and the semantics of waitForReply/timeoutMs, which matter for a fire-and-forget vs. round-trip 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?

Two sentences, no filler, with the core purpose front-loaded and the pointer to stronghold_protocol placed last where it belongs. Nothing repeats the schema or wastes the agent's attention.

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 four-parameter, nested-object, no-annotation, no-output-schema tool that mutates game state, the description should cover prerequisites, the shape of `fields`, and what a reply looks like. It instead offloads all of that to a sibling tool, leaving the agent unable to call this correctly from the definition alone.

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 0% across four parameters, and the description explains none of them: not `type`, not the free-form `fields` object, not `timeoutMs`, not `waitForReply`. Delegating to stronghold_protocol for the field list is helpful for discovery but is not parameter semantics in the description itself, so the coverage gap goes uncompensated.

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

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

States a specific verb and resource: 'Send any normal Stronghold client action', and the enum in the schema makes the action space concrete. It also implicitly separates itself from stronghold_protocol, which is documentation rather than dispatch. The word 'normal' is left undefined, but the resource 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?

It gives one useful routing hint — go to stronghold_protocol for the complete action and field list — which is a real alternative-selection cue. However, it says nothing about prerequisites (e.g., that a connection from stronghold_connect must exist first) or when not to use this tool versus stronghold_observe or stronghold_state for reads.

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

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

With no annotations, the description carries the full disclosure burden, and it does add genuine value by revealing that the adapter manages the private-site login cookie and reconnect token. It still omits key behaviors: whether credentials must be pre-provisioned, idempotency of reconnect, what happens if already connected, and how failures surface.

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

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

Two tight sentences with zero filler, and the core action is front-loaded before the adapter-handling detail. Every clause contributes information.

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

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

The absence of an output schema means the description should say what a successful connection yields (session handle, state), and it does not. Combined with the unexplained 'name' parameter, an agent lacks enough to invoke this confidently on first try, though the core intent is clear.

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 0% for the single 'name' parameter, so the description must compensate and does not — 'name' is never mentioned or explained (presumably the player name, but that is left to inference). The 'player' wording hints at it weakly, but an agent cannot tell what to supply.

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 pair ('Open or resume') and a concrete resource ('real Stronghold player WebSocket session'), so an agent knows exactly what it produces. It does not explicitly contrast itself with siblings like stronghold_disconnect or stronghold_state, but the resource is distinctive enough to place it.

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 'open or resume' phrasing implies this is the session entry point, which a reasonable agent can infer as a prerequisite to the other stronghold_* tools. However, it never states when to call this versus alternatives, whether it must precede action/observe, or what happens if a session already exists.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the session-scoped nature of the connection, but does not explain side effects, idempotency, what happens to the player or ongoing operations, or error behavior when no connection exists.

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 front-loaded sentence with no wasted wording. It states the action and scope 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?

For a simple zero-parameter teardown tool, the description is enough to identify the action, but it is thin given the lack of annotations and output schema. It does not clarify post-disconnect state or failure conditions.

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

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

The tool has zero parameters, so there is no parameter semantics to document. The schema is correspondingly empty, and the description does not need to compensate for missing input fields.

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

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

The description uses a specific verb and resource: "Close ... Stronghold player connection." It also scopes the action to "this MCP session’s" connection, making it distinguishable from the sibling connect/observe/action 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 phrase "Close ... connection" implies the tool is used for teardown or ending a session, but it does not explicitly say when to use it versus leaving the connection open or which sibling to use instead. Usage is inferable but not guided.

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

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

With no annotations, the description carries the full burden and does disclose that this is a read operation, what is returned with and without ids, that fetched pages show read:true, and how topic scoping works. It omits permissions, error behavior, and rate limits, but those are less critical for a guide-reading tool.

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

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

The purpose is front-loaded and the dense details are relevant to calling the tool correctly. The long parenthetical and enumerated lists make it less scannable than it could be, but there is little pure filler.

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

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

For a two-parameter read tool with no output schema and no annotations, the description explains return values and topic/id behavior well enough to invoke it correctly. It leaves gaps around sibling routing and precedence when both optional parameters are provided.

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 0%, so the description must compensate, and it largely does: it enumerates valid ids, explains bond.<bondId> and band.<bandId> formats, and documents all topic enum values including the auto default. It does not clarify what happens if both ids and topic are supplied.

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: reading the game tutorial and match reference pages, with an explicit list of retrievable sections. It is clear what the tool does, though it does not distinguish itself from siblings such as stronghold_lookup or stronghold_protocol.

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 explains the two retrieval modes clearly: providing ids returns sections, while omitting ids returns a table of contents, with topic controlling scope. However, it gives no explicit when-to-use guidance versus sibling tools and no exclusions or alternatives.

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

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

No annotations, so the description must carry the behavioral burden. 'Look up ... record behind one id' strongly implies a read-only fetch, and it reveals that bond records carry thresholds, description and members, but it says nothing about not-found behavior, whether an id can resolve to multiple kinds, or how the two params interact.

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 the return payload first and the id-type enumeration second. The nested parenthetical is dense but every clause conveys new information; nothing is 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?

With no output schema, the description does sketch what comes back ('full game-data record', plus bond-specific fields), but it omits error/not-found semantics and the id-vs-kind relationship, which are the main open questions for a two-param lookup.

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 0%, so the description must compensate — and it does, documenting the id prefix scheme for three kinds, the bare enemy key and token forms, and singling out 'kind: "bond"' with its extra fields. It stops short of explaining when kind is required versus inferable from the id prefix.

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 ('look up') and resource ('full game-data record behind one id') and enumerates the entity types reachable by id. An agent can tell this is a by-id fetch rather than an action/state tool from the sibling list, though it never names a sibling explicitly.

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 id-prefix conventions (chess_, item_, band_), which tells the agent what inputs are valid, but there is no explicit when-to-use/when-not guidance or pointer to alternatives like stronghold_observe or stronghold_state for broader queries.

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

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

With no annotations, the description carries the full load and does so well: it explains compact vs full projection, that absent flags mean false, that unchanged/removed keys are elided under since, and that resync:true signals a full snapshot. It stops short of stating error behavior when disconnected and never explicitly declares the operation read-only, so it falls just short of full disclosure.

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

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

Dense but mostly front-loaded: the read verb and the connected/has_frames gate come first, then the detail modes, then delta semantics. Every sentence carries information, though the resync clause is compressed to the point of ambiguity.

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 tool with no annotations and no output schema, this covers the mechanics an agent needs: projection modes, delta protocol, and section toggles. The gaps are the response envelope (where rev lives) and failure behavior when not connected.

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 0%, so the description must compensate, and it does: detail's default and both modes, since as the prior response's rev with delta semantics, and includeField/includeReport omitting sections. The "resync:true" sentence is ambiguous because resync is not an input parameter in the schema, leaving the reader unsure whether it is a request flag or a response marker.

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?

"Read the match" names a specific verb and resource, and the detail/since mechanics make it clear this is an observation of match state rather than an action. It does not, however, differentiate itself from the sibling stronghold_state, which an agent could plausibly confuse it with.

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 prerequisite "Check connected and has_frames first" gives a real usage gate, but it doesn't say what to do when that check fails (presumably stronghold_connect) or when to prefer this over stronghold_state. Usage is implied rather than routed.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that this is a read operation and hints at a performance concern by warning against loading the entire catalog, but it omits return format, pagination, error behavior, and how the two filters interact.

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

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

The description is two tightly written sentences with no filler. The core action comes first, followed by the filtering guidance that directly affects invocation.

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 two optional parameters, no annotations, and no output schema. The description covers the basic action and filtering intent, but it leaves the agent without a clear picture of the returned data or edge-case behavior, making it only minimally 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?

Schema description coverage is 0%, so the description must add meaning. It gives examples for both parameters (type e.g. g.move, prefix e.g. room.) and explains their purpose, but it does not clarify prefix-matching semantics, whether filters combine with AND/OR, or what happens if both are supplied.

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

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

The description gives a specific verb and resource: “Read game action fields,” and adds the available filtering modes. It does not explicitly differentiate this catalog-reading tool from siblings such as stronghold_lookup or stronghold_observe, so it falls short of a 5.

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 advises filtering by type or prefix to avoid loading the entire catalog, which gives practical usage context. However, it does not state when to choose this tool over alternatives such as stronghold_lookup or stronghold_observe, so usage remains implied rather than 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?

No annotations are provided, so the description carries the full burden. It discloses the content of the return payload (frame types, queued events), which is real value, but says nothing about whether reading drains the queued events, whether frames accumulate, or whether it blocks. 'Read' implies non-mutation but that is inference, not disclosure.

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

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

Two sentences, zero waste: the payload description is front-loaded and the sibling contrast follows. Nothing repeats the title or pads the 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?

The description adequately explains what comes back, but with no annotations, no output schema, and an undocumented parameter, an agent still lacks the includeRecent semantics and any indication of queue-draining behavior — gaps that matter for a session-state reader.

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

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

The single parameter includeRecent has 0% schema description coverage and is never mentioned in the description, leaving its meaning and default entirely unexplained. With one undocumented parameter the schema cannot compensate, so the description should have covered it.

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 (Read) and a precise resource (raw server frames received by this real player session), then enumerates the frame kinds covered (room.state, m.public, m.private, m.field, battle frames, queued events). It also names the sibling it differs from, so an agent can distinguish it from stronghold_observe without opening a schema.

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

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

Explicitly routes the decision use case to stronghold_observe ('renders the same frames for deciding a turn'), implying this tool is the raw-inspection alternative. It stops short of stating a positive when-to-use condition (e.g. debugging, verifying wire payloads) or any exclusions, so a 4 rather than 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?

No annotations exist, so the description carries the full burden. It correctly signals the blocking/long-poll nature ("wait for the next live") and the live-stream origin of events, but leaves out what happens at timeout, whether queued events can be missed, and whether a connection must already be open — all material for a blocking 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?

Two sentences, zero filler, with the core operation front-loaded and the usage hint second. Nothing needs trimming.

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

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

With no annotations, no output schema, and 0% parameter documentation, the description has to do all the work and does not. An agent still doesn't know the returned event shape, the timeout result, or the prerequisite connection state before calling a blocking wait.

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 0% for two parameters. The mention of "room/match/battle updates" loosely hints at valid values for `types`, but it never states that these are the filter values, nor how an empty/omitted array behaves. `timeoutMs` gets no explanation of default or timeout behavior beyond the schema's min/max bounds.

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 action and resource: blocking for the next live server event, with a hint of what events arrive (room/match/battle updates). It is distinguishable from stronghold_state and stronghold_lookup, but the near-synonym stronghold_observe is never mentioned, so the boundary between 'wait' and 'observe' remains fuzzy.

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

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

"Use this after an action to observe room/match/battle updates" gives one implied trigger, which is more than nothing. However, it never says when NOT to use it, whether it should be preferred over stronghold_observe or stronghold_state, or whether it can be called before connecting.

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