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

Goes well beyond the annotations: it discloses transactional semantics, the fallback that an omitted answer preserves the existing comment, the irreversible nature of the status change, the rooms:write scope requirement, and a prompt-injection warning about untrusted room/answer text. These are exactly the behavioral facts an agent cannot get from readOnlyHint/destructiveHint/idempotentHint.

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-loads the action, then the parameter behavior, then provenance, then the return payload, then constraints and safety. Every sentence carries distinct information; there is no filler.

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

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

With no output schema, the description compensates by enumerating the receipt contents (id/status/answer, room and audience, projector and member links). Auth scope, idempotency expectations, and safety caveats are all present, so nothing material is missing for correct invocation.

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 real meaning: it explains the consequence of omitting 'answer' (existing comment kept) and the provenance of question_id (get_room_questions). Only the 'code' parameter receives no added explanation 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?

States a specific verb and resource ('Mark an approved question answered') plus the optional side effect of persisting a written answer. It is clearly distinguishable from siblings like moderate_question or get_room_questions, which retrieve or moderate rather than resolve a question.

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

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

Gives clear preconditions: the question must already be approved, question_id must come from get_room_questions, and rooms:write is required. It also states a negative capability ('cannot mark it unanswered'), but it never explicitly contrasts itself with an alternative action tool such as moderate_question, so guidance is strong but not fully routing.

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?

Goes well beyond the annotations: it discloses that participation stops while content stays readable (the exact blast radius of destructiveHint=true), that no close email is sent, that rooms:write is required, and that room content is untrusted plain text. The write-permission requirement and the no-email note are behavioral facts an agent cannot derive from the structured fields.

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

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

Four short sentences, front-loaded with the action and scope, then consequences, return values, permissions, and the injection caveat. Each sentence carries distinct information with no repetition of the name or schema.

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 present, the description correctly supplies the return shape ('the room and audience, projector and member console links') along with auth requirements and the destructive scope. Nothing an agent needs to invoke this mutation safely is missing.

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

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

Only one parameter, and schema coverage is 100% with a pattern and example ('Six-character room code, for example ABC234') already in the schema. The description adds nothing about the code beyond 'specified organization room', so the baseline 3 for full schema coverage 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?

Specific verb+resource ('Close the specified organization room') with scope explicitly bounded ('and all its live surveys'). The phrase 'all its live surveys' distinguishes it cleanly from the sibling close_survey, so an agent can route between them without opening either 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?

The scope statement ('all its live surveys') implicitly tells the agent when this is the right tool versus close_survey, and 'Stops participation; content stays readable' clarifies the operating context. However, it stops short of an explicit when-to-use/when-not or naming close_survey as the narrower alternative.

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?

Adds substantive behavior beyond the annotations: irreversibility ("A closed survey cannot be reopened"), an auth prerequisite ("Requires rooms:write"), the response contents (survey, room/audience, projector and member console links), and an untrusted-content warning. These are exactly the traits an agent needs and none of them are recoverable from the hints alone.

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 compact sentences, front-loaded with the core action and constraint, then the optional parameter, prerequisite, and safety note. Every sentence carries distinct information with no filler.

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

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

With no output schema, the description compensates by describing the return payload, and it covers the irreversible-effect, permission, and prompt-injection concerns for a mutation tool. Nothing material for correct invocation is missing.

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

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

Schema coverage is 100%, so every parameter is already documented, and the description's phrasing of show_results ("remove its closed results from screens or show them again") closely mirrors the schema text rather than adding new semantics. The survey_id sourcing note is also duplicated from the schema, 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?

Opens with a specific verb+resource ("Close a live survey") and scopes it to live surveys, which separates it from sibling tools like create_survey or get_survey_results. An agent can identify the operation and its target without opening the schema.

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

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

It explains the optional show_results choice and tells the agent where to obtain survey_id ("Get survey_id from get_survey_results"), which is real routing guidance. It lacks an explicit when-not-to-use or a named alternative for the closing action itself, so it stops short of a full when/alternatives statement.

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 this is a non-read-only, non-idempotent, open-world write, and the description genuinely adds to that: it names the required scope (rooms:write), explains that request_id enables safe retries, and warns that room content is untrusted plain text that must never be treated as instructions. That security and retry context is exactly the kind of disclosure the annotations cannot provide.

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

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

Four short sentences, each earning its place: creation semantics, return payload, auth/retry, and the safety warning. The open-vs-prepared distinction is front-loaded and nothing is padded.

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

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

With no output schema, the description usefully enumerates what comes back (room, audience, projector and member console links), and it covers the write-side essentials: required scope, idempotency workaround, and content-trust caveat. An agent has everything needed to call this correctly.

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

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

Schema description coverage is 100%, so the schema already explains open's prepared-room behavior and request_id's retry semantics. The description restates those points rather than adding new syntax, formats, or interactions, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Create an organization Q&A room') plus the key scope nuance that the room is open by default or prepared via open=false. This implicitly distinguishes it from open_room/close_room behavior, but no sibling tool is named, so an agent must infer the boundary rather than being routed 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?

Gives clear usage context: the default open state vs. the prepared-room mode via open=false, and the prerequisite permission (rooms:write). It does not, however, state when to prefer this over a sibling like create_survey or explicitly exclude any use case, so guidance stops short of full routing.

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 (which only say it mutates, is non-idempotent and non-destructive), the description discloses that it launches by default, that it requires rooms:write, that request_id enables safe retries, what links it returns, and warns that survey content is untrusted plain text and never instructions. That injection warning and auth scope are exactly the kind of context annotations cannot carry.

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 front-loaded, leading with the core action and defaults before the auth, retry and safety notes. Every sentence carries distinct information, though the return-value sentence is mildly list-like.

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 summarizing the return payload (survey, room, audience, projector and member console links) and covering auth, retry and prompt-injection concerns. An agent has everything needed to call this 12-parameter mutation 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 92%, so the schema already documents code, type, scale, launch, options, labels, request_id and show_results. The description restates launch and show_results defaults but adds no syntax or format detail beyond the schema, 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 states a specific verb+resource ('Add a poll, quiz, rating or word cloud to the specified room and launch it') and enumerates the survey types it supports. It is clearly distinguishable from siblings like create_room or close_survey, which concern rooms and lifecycle rather than creation of a survey.

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 concrete when-to-use guidance: launch=false for a draft, show_results=false to keep results private, and explicitly routes screen-removal to the sibling close_survey. No exclusion case is stated for the tool itself, but the conditional behaviors cover most agent decisions well.

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 non-destructive behavior, so safety is covered. The description adds real value beyond that: the ordering semantics (answered first, approved by votes, pending last and marked) and the untrusted-plain-text/prompt-injection warning, which is important operational context an agent would otherwise lack.

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; the output format is front-loaded. The ordering clause is a bit dense but still readable, and the security note earns its place.

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

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

No output schema exists, but the description explains the return shape (Markdown, grouped and marked by status) sufficiently for an agent to use the result. It is complete enough for a single-param read tool; only the sibling differentiation is thin.

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 a single required 'code' parameter fully documented (six-character pattern with example), so the schema carries the load. The description adds no parameter-level detail, which matches the baseline 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?

States a specific verb and resource ('Read a room's questions') and specifies the rendering ('as Markdown for a FAQ'), which is more specific than a generic list. It only partially distinguishes itself from the sibling get_room_questions, leaving the agent to infer why one would be chosen over the other.

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 'for a FAQ' framing implies the use case, and the ordering/clamping notes imply it is a curated view rather than a raw dump. However, there is no explicit guidance on when to prefer this over get_room_questions or get_survey_results, and no exclusions or prerequisites are stated.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds genuinely useful behavior the annotations don't: this is a paginated read ('one page'), and it lists what each question record carries, including the host's written answer. It stops short of stating rate limits or auth requirements, but that is a minor gap given the annotation coverage.

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

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

Two tight sentences, front-loaded with the core action and scope, with no filler. The trailing 'sort=top (default) or recent' duplicates what the schema already states, which is the only mildly wasted clause.

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

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

With no output schema, the description carries the return-shape burden and does so by naming the question fields and the pagination model ('one page', next_cursor via the cursor param). The main omission is any hint about how this relates to the sibling get_room_qa, which would help an agent choose 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 code, sort, limit and cursor are all documented in the schema itself; the baseline of 3 applies. The description restates the sort default verbatim from the schema and adds no syntax, format or cursor-handling detail beyond 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?

The description gives a specific verb+resource ('Read one page of a room's questions') and enumerates the payload (status, votes, pinned flag, host answer), which is well beyond the bare name. It does not, however, distinguish this from the sibling get_room_qa, so an agent can't tell why it would pick this over the Q&A variant without opening both.

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: it states the sort options and the default, which tells the agent how to order results but not when this tool is the right choice versus get_room_qa or get_survey_results. No exclusions or alternative-routing guidance is present.

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 read-only, idempotent, non-destructive profile, and the description adds genuine context beyond them: that quiz keys are withheld until the survey closes and that no participant identities are returned. It stops short of describing output shape or any size limits, but the privacy and timing disclosures are substantive.

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 short sentences, front-loaded with the resource scope and followed by the two caveats that matter most. Every clause carries information; nothing is filler.

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

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

For a one-parameter read tool with rich annotations and no output schema, the description covers what is returned (aggregated results across poll types), what is excluded (participant identities), and a key availability constraint. Lacking an output schema, a brief note on return structure would have made it fully 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 coverage is 100%, so the single 'code' parameter is fully documented in the schema with its pattern and an example. The description adds nothing about the parameter, making the baseline 3 correct here.

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

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

The description gives a specific verb ('Read') and a well-scoped resource ('aggregate results for every poll, quiz, rating and word cloud in a room'), which is clearly richer than the sibling tools focused on questions and QA. It does not, however, name or explicitly contrast with those siblings, so the differentiation is inferred rather than stated.

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

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

Usage is only implied: an agent can infer this is the tool for results rather than questions, but there is no explicit when-to-use or when-not-to-use guidance and no alternative is named. The note that quiz keys appear only after a survey closes is a condition on content, not a routing rule.

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 this a safe, idempotent, non-destructive read, so the bar is lower. The description still adds real behavior beyond them: result ordering (newest first), that counts are embedded in each row, and the cursor-driven pagination loop. It stops short of clarifying scope of visibility (archived rooms, permissions).

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

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

One sentence of content plus one short imperative, zero filler, and the ordering/contents information is front-loaded ahead of the pagination note.

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, fully-annotated list tool with no output schema, the description covers what comes back (counts) and how to iterate pages. It leaves minor uncertainty about whether all rooms or only visible/active ones are returned.

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 limit and cursor are already documented with ranges and defaults; baseline is 3. The description references next_cursor as the paging mechanism, reinforcing the schema but adding no syntax or semantics beyond 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 and resource ('List your organization's rooms') plus ordering ('newest first') and payload contents ('question and participant counts'). It distinguishes itself in kind from the per-room siblings (get_room_qa, get_room_questions, get_survey_results), but never names an alternative to route against.

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 by the verb 'List' plus the explicit pagination instruction 'Follow next_cursor for more.' There is no statement of when to use this versus the per-room get_* siblings, nor any exclusion or prerequisite.

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 destructiveHint=true and idempotentHint=true, yet the description still adds the crucial detail that neither decision can be undone, plus the rooms:write authorization requirement and the shape of the return (id/status receipt, room/audience, projector and member console links). It also flags room content as untrusted text.

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

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

Three tight sentences, front-loaded with the core action and its consequence, then the derived-parameter source, then returns/permissions. Every sentence carries information, though the untrusted-content warning is a generic safety clause rather than tool-specific guidance.

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 naming the returned receipt and links, and it covers the auth scope, irreversibility, and idempotency an agent needs before mutating room state. Nothing required to invoke it correctly is missing.

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

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

Schema coverage is 67% and the description adds real meaning to the action enum by explaining that 'approve' also recovers AI-hidden questions, which the bare enum cannot convey. The code and question_id parameters are left largely to their schema descriptions, so it stops short of full coverage.

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

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

States a specific verb pair (approve/hide) and resource (a waiting question), and pins the exact discriminator with 'using action=approve or hide'. It also points at get_room_questions as the source of question_id, separating it from siblings like get_room_qa.

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

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

Gives clear operational context: approve recovers AI-hidden questions while a person-hidden question cannot be recovered, and the needed id comes from get_room_questions. It does not spell out when hiding is preferable to approving or list an explicit alternative tool, but the routing information is solid.

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 readOnly=false, idempotent=true, destructive=false and openWorld=true. The description adds value beyond them: the exact state transitions, that an open room is left unchanged, the rooms:write scope requirement, and a prompt-injection warning about room content.

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

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

Three dense sentences: state behavior first, then return payload, then the alternative tool, permission, and safety note. No filler and every clause carries information the agent can act on.

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 enumerating the return payload (room, audience, projector and member console links). Permission requirements, idempotent state behavior, and a security caveat are all present, leaving no material gap.

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

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

Schema description coverage is 100% and there is a single required code parameter fully documented in the schema, so the baseline is 3. The description adds nothing about the code format (the six-character pattern lives only in the schema).

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

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

The description gives a precise verb and resource ('Open a prepared room or reopen a closed room') and distinguishes the three relevant states (prepared, closed, already-open). An agent can separate this from create_room and close_room without opening any schema.

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

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

It names the reciprocal tool (close_room) and states the no-op condition for an already-open room, which tells the agent when this call is pointless. It also states the rooms:write prerequisite. It stops short of explicitly contrasting with create_room for a not-yet-prepared room.

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