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 lead with 'Read-only' plus the exact field set returned, which meaningfully discloses the safety profile and return shape. It omits behavior outside an open booth (error vs nulls), auth requirements, and whether values are live or cached snapshots.

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 that starts with the safety profile and then lists the return fields in priority order. The comma-run list is dense but each clause carries information; 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?

No output schema exists, so enumerating the returned fields in the description is exactly the needed compensation, and the lone parameter is fully documented in schema. The remaining gap is relational: it does not situate itself among status, meeting_status, and capacity_status.

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%; the schema already explains that meeting_id comes from create_broadcast or join_broadcast. The description adds no additional parameter semantics, so baseline 3 applies.

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

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

Names a specific verb+resource: reading booth state, with an explicit enumeration of what is returned (open/on-air/video/watchers/start time/Visit link). It is clear what it does, but it never distinguishes itself from the many similar read tools in the sibling list (status, meeting_status, capacity_status, snapshot).

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

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

There is no statement of when to use this versus the other state-reading tools; the agent must infer that 'booth' refers to a specific broadcast sub-entity. No prerequisites, no exclusions, no named 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?

With no annotations at all, the description carries the full behavior burden, and it does disclose the key nuance that a live or in-overrun occurrence is by default left untouched. However, for a destructive operation it never states irreversibility, whether participants are notified, whether cancelled occurrences can be restored, or what the call returns.

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, zero filler, with the series/occurrence behavior front-loaded. 'Leaves a live occurrence unless leave_if_live is false' is slightly elliptical phrasing that costs a beat of parse time but 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?

Given a destructive, unannotated tool with no output schema, the description covers the targeting logic adequately but omits consequence information an agent needs before calling: irreversibility, permission requirements, and side effects on attendees. It is enough to invoke correctly but not enough to invoke safely.

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

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

Schema coverage is 100%, so both the omission semantics for 'occurrence' and the true default for 'leave_if_live' are already documented in the schema. The description restates the same behavior compactly rather than adding formats, constraints, or edge cases the schema lacks, so baseline 3 applies.

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

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

States a specific verb and resource: 'Cancels one occurrence, or the series', which an agent can distinguish from update_schedule or end_meeting. It does not explicitly name or compare against those siblings, but the scope (occurrence vs series) is a real disambiguator.

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

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

It implies when to target a single occurrence versus the whole series ('when occurrence is omitted'), which is genuine usage guidance for the parameters. It gives no guidance on when to cancel at all versus reschedule via update_schedule, and no prerequisites or preconditions are mentioned.

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 and no output schema, the description carries the full burden; it does usefully disclose the shape of the answer (level values, seated/waiting lists, future clashes within a horizon) which an agent could not otherwise know. It says nothing about freshness guarantees beyond 'latest', cost, or that the call is a non-mutating read, leaving gaps for a zero-annotation 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?

Two tight sentences: the first front-loads what the payload contains, the second front-loads when to call. Nothing is redundant with the name or title, and there is no filler.

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

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

For a no-parameter, no-output-schema read tool, the description gives enough — what comes back and when to reach for it — to invoke it correctly. It could go further by clarifying whether the 'horizon' is fixed or whether the snapshot is live versus cached, but nothing essential is missing.

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

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

The tool takes zero parameters, so the baseline is 4. The description doesn't need to explain inputs, and the mention of a 'horizon' doesn't create a parameter the agent must 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?

The description names a specific resource (the latest capacity picture) and enumerates what it contains: level (ok/near/reached), who is seated, who is waiting, and future clashes within the horizon. That is far more specific than a sibling like 'status' or 'meeting_status', though it doesn't explicitly say how it differs from those.

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 triggers — 'on connect' and 'when the human asks' — which is real when-to-use guidance rather than an implied purpose. It stops short of exclusions or naming an alternative (e.g., status vs meeting_status) for capacity questions.

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 burden well: it discloses that the effect is local to this computer, that it is not the End step, and that viewers see the host leave if the host was live. It stops short of saying whether the booth can be reopened (open_booth) or what state the meeting is left in.

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 action and its scope, followed by the user-visible consequence and the sibling routing. 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?

For a one-parameter, no-annotation, no-output-schema tool, the description covers scope, side effect, and the alternative. It leaves minor gaps around follow-up state (reopening, whether the meeting persists), but nothing an agent needs to call 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?

The single meeting_id parameter is fully described in the schema (100% coverage), including its source (create_broadcast or join_broadcast). The description adds nothing about parameters, which is acceptable at this coverage level – 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 ('Closes the host seat') plus a precise scope qualifier ('on this computer'), which immediately separates it from end_broadcast. An agent can distinguish it from open_booth and end_broadcast 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?

Explicitly routes the agent to the alternative: 'Use end_broadcast to end it for everyone.' The condition for choosing this tool is implied by 'without the End step.' It doesn't address the potentially confusable leave_meeting, but the primary alternative is named.

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 well: it discloses the side-effect profile (nothing is created live, no one joins, no messages sent) and that the host password is used only for this call and is never stored, logged, or returned. It stops short of covering re-invocation behavior (e.g., whether calling twice mints two broadcasts), which matters for a creation 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?

Front-loaded with the mint action and return payload, then the non-effects, then the stream flag, then the password caveat. Dense and mostly efficient, though the host password guarantee is stated twice (body and again at the end), which is slight 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?

No output schema exists, and the description compensates by enumerating the returned payload (title, times with time zone, link, Visit link, description, access details, roles) and its dual form as fields and ready-to-send text. Combined with the effect and credential disclosures, an agent has everything needed to call it correctly.

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

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

Schema coverage is 100%, so every parameter is already documented in the input schema, making 3 the baseline. The description adds a little context on the stream flag ('Stream to friends broadcast') and reiterates the host_password handling, but largely repeats what the schema descriptions already state.

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 ('Mints a GifOS broadcast') followed by exactly what it returns: watch link plus invite fields and ready-to-send text. It also distinguishes itself from siblings by asserting 'Nothing goes live, nothing joins and nothing is sent', separating it from go_live, join_broadcast, and send_chat.

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 exclusions ('nothing goes live, nothing joins, nothing is sent') effectively route the agent away from go_live/join_broadcast toward this tool when it only wants to mint an invite. However, it never names a sibling explicitly or says 'use this when you only need the link and invite', so the guidance is inferential rather than 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?

With no annotations, the description carries the full burden and does well: it discloses that the effect is global ('for everyone'), that viewers are notified, that the booth closes, and the non-obvious side effect that the note-taking bot persists. It omits irreversibility, permission requirements, and recording/transcript handling, which keeps it from a 5.

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

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

Two tightly written sentences with the global scope stated first and the bot caveat last. Every clause conveys a distinct behavioral fact with no repetition of the name or title.

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

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

For a single-parameter destructive action with no annotations or output schema, the description covers the important side effects and the sibling boundary. What is missing is the return/confirmation behavior and whether the action can be undone, which an agent performing an irreversible termination would benefit from.

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

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

There is one parameter with 100% schema description coverage, so the schema already explains meeting_id and its source. The description adds no additional semantics about the parameter, making the baseline 3 correct.

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

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

The description names a specific verb and resource ('Ends the broadcast') and then enumerates the concrete effects on host, viewers, and booth. The closing note about the note-taking bot staying until end_meeting actively distinguishes this tool from the end_meeting sibling.

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

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

It gives clear context for when this applies (terminating a broadcast versus a meeting) and implicitly routes the agent to end_meeting when the bot should also stop. It stops short of an explicit 'use X instead of Y when...' rule, so the exclusion is inferential rather than 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?

No annotations are provided, so the description carries the full burden, and it does well: transcript persistence, that other participants remain, that no one can close the meeting for everyone, and that a scheduled order inside its window is marked left early. Missing are idempotency and error behavior, which keeps it short of a 5.

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

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

Three short sentences, front-loaded with the core effect and then the differentiating constraints. No filler or restatement of the title.

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 low-complexity, one-parameter tool with no output schema, the description covers the side effects an agent needs before calling. It stops short of describing the response or failure modes, but nothing essential is absent.

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?

Single parameter with 100% schema description coverage, including its origin (create_broadcast or join_broadcast), so the schema already does the work. The description adds no meaning beyond it, which is the baseline case.

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 concrete verb and effect: the bot leaves and the transcript is saved. It explicitly names the sibling it duplicates ("Same result as leave_meeting") and clarifies scope (other participants stay, no owner can close a GifOS meeting), so an agent can distinguish it without opening the schema.

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

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

Explicitly tells the agent this is functionally equivalent to leave_meeting, which resolves the main selection question between the two siblings. It doesn't state preconditions (e.g. what happens if the bot isn't in the meeting), so not a full when/when-not treatment.

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 behavioral burden. It usefully discloses that hand, microphone, and camera states are returned only 'when Meeting Bot reports them,' and that contract version 1 returns the people list only. However, it omits other relevant behavior such as data freshness, failure modes, and whether the call is read-only or has 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 short and front-loaded with the core purpose: identifying who is in the room. Each sentence adds useful information, including the sibling distinction and version contract. It is efficient, though the contract version sentence is slightly cryptic without additional context.

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

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

For a read-only getter with one well-documented parameter and no output schema, the description explains the returned contents, conditional fields, alternative snapshot tool, and version-specific behavior. It lacks some detail about output structure and data freshness, but overall it provides enough context for 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?

The schema has 100% description coverage for its single parameter, meeting_id, including its source from create_broadcast or join_broadcast. The description adds no additional parameter semantics beyond what the schema already provides. With high coverage and one simple parameter, the baseline of 3 is appropriate.

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

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

The description clearly states the resource: the people list for a meeting, including hand, microphone, and camera status when available. It explicitly distinguishes itself from the snapshot sibling by noting snapshot is the same list plus a PNG. It is specific enough for an agent to identify the tool's output, though it phrases purpose as a question rather than a direct verb+resource statement.

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

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

The description names the alternative snapshot tool and explains the condition for using it: snapshot provides the same people list plus a PNG of the page. This gives clear selection guidance between the two tools. It does not provide explicit exclusions or prerequisites, but the sibling contrast is strong enough for a 4.

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 a good job: it discloses the return shape (one "speaker: words" line per caption), the bot-line labeling convention, and the availability lifetime spanning live and post-end_meeting. It omits any mention of size limits, truncation, or pagination for long meetings, which is the remaining behavioral gap.

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

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

Three short sentences, each carrying distinct information: return format, bot-line special case, and availability window. Nothing is padded and the most important fact (what you get back) leads.

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

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

For a single-parameter read tool with no output schema, the description adequately covers what is returned and when it can be called. The one missing piece is whether very long transcripts are truncated or paged, which matters for a whole-transcript fetch.

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 exists and its schema description is fully covered at 100%, including a pointer to create_broadcast/join_broadcast for obtaining the id. The description adds no parameter-level detail beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource ("Returns the transcript") plus the exact serialization format, which is unusually concrete. It does not, however, distinguish itself from the sibling tail_transcript, so an agent must infer that this one returns the whole transcript rather than streaming new lines.

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?

"Works while the meeting is live and after end_meeting" gives a clear validity window that tells the agent when the call will succeed, including after teardown. It stops short of naming tail_transcript as the alternative for incremental reads, so the selection versus that sibling is left 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?

With no annotations, the description carries the full burden and does well: it discloses the real-world side effects (camera and mic activated, audience sees/hears the local machine) and the media-source fallback via GIFOS_BOOTH_CAMERA_FILE. It omits failure/idempotency behavior (already live, missing meeting, permission errors) and does not state whether the action is reversible except implicitly via end_broadcast.

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, both earning their place: the effect is front-loaded and the fallback condition follows immediately. No restatement of the title 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?

For a one-parameter, annotation-free tool with no output schema, this covers what the action does and the key branch to a sibling. The remaining gap is state prerequisite and error behavior, which matters somewhat for a live-broadcast mutation but is minor at this size.

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 the schema description already covers it fully (schema coverage 100%), including its origin from create_broadcast or join_broadcast. The description adds no additional semantics about meeting_id, 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?

Names a specific verb and resource ('Starts the live broadcast') and immediately specifies the concrete effect: host camera and microphone on, viewers hear and see the host from this computer. That distinguishes it clearly from siblings like play_video and share_content, which do not turn on local devices.

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

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

Gives an explicit precondition and an explicit alternative: it needs a camera on this computer (or GIFOS_BOOTH_CAMERA_FILE), and without one the agent should call play_video instead. It does not mention other relevant states (e.g., whether the booth must be open via open_booth first, or what happens if already live), so it stops short of full when/when-not coverage.

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 useful work: it discloses that no calendar is contacted, that unexpandable recurrence rules are reported rather than stored, and that over-capacity items are stored and surfaced in conflicts — real partial-success semantics an agent needs. Missing are atomicity/return-shape details, so it stops short of a 5.

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

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

Five short sentences, roughly 50 words, with failure semantics front-loaded after the purpose line. Nothing is padded, though the opening sentence is cryptic enough to require a second reading.

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

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

For a single-parameter, no-output-schema, no-annotation tool, the description covers the essential unknown: partial-failure behavior on recurrence and capacity. It leaves the response shape of "reported" and "conflicts" implicit, which is the main residual gap.

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

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

Schema coverage is 100% for the single orders parameter, so baseline would be 3. The description adds meaning by equating each item with a "schedule_meeting body plus external_id," letting an agent reuse the sibling tool's schema knowledge rather than re-deriving 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 establishes a specific operation: bulk creation of schedule orders, with each item being a schedule_meeting body plus an external_id. The reference to schedule_meeting ties it to a sibling with clearer semantics, but the phrasing "Bulk path for a calendar you have already read" is elliptical and never plainly says it creates/upserts schedule entries.

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

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

"Bulk path" and "a calendar you have already read" imply when to reach for this over the single-item schedule_meeting, but the alternative is never named as an alternative, and no explicit when-not condition is given. The use case is implied rather than 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?

With no annotations, the description does add real behavioral context: the bot is a passive viewer, never goes on air, and produces a transcript. It omits what happens on failure, whether joining twice is idempotent, permission/auth requirements, and whether the broadcast is ended or left running.

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

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

Three short sentences, front-loaded with the action, followed by the key safety clarification and the recommended next step. 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?

For a two-parameter, annotation-free tool, it covers what the bot does, what it does not do, and how to read the results, which substitutes for the missing output schema. A note on return value (e.g. a handle or id) or on re-joining would make it 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 100%, so both the link format (…/run.html#v=…&bc=1) and the topic label are already documented. The description adds no further meaning about how topic is used or what happens if it is omitted.

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 (Meeting Bot opens a GifOS broadcast link as a viewer) plus the resulting behavior (transcribes the Stage). The phrase 'as a viewer' and 'It never goes on air' separates it from go_live and create_broadcast among the 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?

Explicitly frames the follow-up path: 'Use wait_lines or get_transcript to follow it,' naming the alternatives for consuming the transcript. It doesn't spell out exclusions such as when to use create_broadcast or go_live instead, but the passive-viewer framing implies it.

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 does real work: it discloses that the transcript is saved, that other participants remain, and that a scheduled order inside its window is marked left early. It omits idempotency, permission requirements, and behavior when the bot is not in the meeting.

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 its effect, then the trigger, then the edge-case behavior. No filler and no repetition of the title.

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?

Covers the outcome, the trigger, the effect on other participants, and the scheduling side effect, which is more than most single-parameter tools offer. Missing error/idempotency behavior and any mention of what is returned, though with no output schema that last gap is minor.

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%, so the schema already documents meeting_id including its provenance (create_broadcast or join_broadcast). The description adds nothing about the parameter, which is the expected baseline when the schema is complete.

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 actor (the bot leaves) plus the key side effect (transcript saved), and distinguishes the scope from end_meeting by noting other participants stay. The line 'Same result as end_meeting' muddies the distinction slightly, since it implies the two tools are interchangeable when the trigger differs.

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

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

Gives an explicit trigger condition ('Call this when someone asks the bot to leave') and references the sibling end_meeting as an equivalent-outcome alternative. It stops short of stating when to choose end_meeting over this tool, leaving that boundary to inference.

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

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

With no annotations, the description carries the full burden. It usefully discloses ordering ('newest first') and the state vocabulary ('scheduled, live, ended'), which is genuine behavioral context about the payload. It says nothing about pagination, result limits, auth requirements, or whether the list is scoped to the caller.

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

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

A single sentence with no filler; scope, ordering, and state are front-loaded in one pass. Every clause earns its place.

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

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

For a zero-parameter read tool with no output schema, the description covers the essentials: what is listed, in what order, and the state values returned. The main remaining gap is unbounded-result behavior (pagination or truncation), which matters for a list tool but is a single omission.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. No parameter claims are made that could mislead.

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

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

Names a specific verb+resource ('Meetings') and pins down scope ('this server created or joined'), ordering ('newest first'), and the returned state field. It reads as a noun phrase rather than an action statement, and it never names a sibling, but no other tool in the set enumerates meetings, so an agent can still 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?

Usage is only implied: an agent can infer this is the enumeration tool, and the scope qualifier ('this server created or joined') hints at when results apply. There is no explicit when-to-use, no exclusion, and no routing against adjacent tools such as 'status' or 'get_transcript'.

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 burden and does disclose meaningful behavior: ordering, recurrence expansion within the window, omission of room/admin passwords, and the meaning of conflicts. It still omits read-only status, auth requirements, and pagination/limits, so it is not fully transparent.

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 ordering rule, and each sentence adds distinct operational or output 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?

For a no-annotation, no-output-schema tool with five parameters, the description is helpful but incomplete: it explains recurrence, password omission, and conflicts, but not the full row shape, default window behavior, pagination, or permissions.

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 defines from, to, phase, timezone, and flag_overlaps. The description adds context about window recurrence and conflicts but does not add parameter-level syntax or clarify flag_overlaps 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 states what is returned, in what order, and notes recurrence expansion, which makes clear this is a schedule-listing tool. It does not explicitly name or distinguish itself from sibling list_meetings, but the title and tool name resolve the resource.

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 no explicit when-to-use or when-not-to-use guidance, and it does not mention alternatives such as list_meetings or schedule_meeting. Usage is only implied by the window-oriented return behavior.

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, but it does usefully disclose that the output is raw rows rather than a finished summary and that prose generation is the caller's job. It does not describe ordering, row fields, or pagination beyond the schema.

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 terse fragments with zero filler, and the key point (it returns rows, not a summary) is front-loaded. It is a little cryptic, but nothing is wasted.

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

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

There is no output schema, so the description should explain the shape of the returned rows, yet it leaves that entirely undefined. For a data-retrieval tool with no annotations and no output schema, the caller is left uncertain what it actually gets back.

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 optional parameters (since, meeting_ids) are fully documented in the schema. The description adds no parameter meaning beyond that, so 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 says it returns 'rows a summary is built from' and explicitly distinguishes itself from a summary, which gives a vague sense of the resource (raw cross-meeting data). But it never states a clear verb or what a 'row' is, leaving the purpose only implied.

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 tells the agent this is not the summary and that you write the prose, which hints at usage as a data-gathering step. However, it names no alternatives among the many siblings (e.g., tail_lines, get_transcript) and gives no explicit when/when-not conditions.

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

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

With no annotations, the description does useful work by disclosing returned state categories, noting a warning when the network blocks direct connections, and clarifying that passwords and model keys are not exposed. However, it does not explicitly state read-only behavior, permission requirements, or absence of side effects, leaving meaningful behavioral gaps.

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

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

The description is front-loaded with the key framing ('One meeting, one object') and packs relevant return-state details efficiently. It is slightly dense and run-on, but each clause contributes useful context rather than repeating 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, the description appropriately fills that gap by naming the main returned fields and one important warning condition. It remains incomplete on auth/read-only behavior and sibling disambiguation, but it is sufficient for an agent to understand what the call returns.

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

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

Schema coverage is 100%, and the schema already explains that meeting_id identifies the room and comes from create_broadcast or join_broadcast. The description adds no additional parameter semantics beyond that, so the baseline of 3 is appropriate.

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

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

The description clearly frames the tool as returning status for one meeting ('One meeting, one object') and enumerates the returned state fields, which distinguishes it from list-oriented siblings. It does not explicitly distinguish itself from similarly named siblings such as status or get_meeting_state, so it stops 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?

There is no explicit guidance on when to use this tool versus alternatives such as status, get_meeting_state, or list_meetings. The only contextual hint is the schema requirement that meeting_id comes from create_broadcast or join_broadcast, which is prerequisite information rather than usage guidance.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the blast radius (transcription only, not the whole bot), but says nothing about reversibility (unmute exists), idempotency, required meeting state, or any permission/authorization requirements for a mutation-like operation.

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 with the effect front-loaded; nothing is padded. The second sentence partially restates the first ('captions' vs 'transcription'), a minor redundancy rather than waste.

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 one-parameter tool with a fully documented schema, the description is adequate but thin: no output schema and no annotations mean the agent gets no information about what happens after the call, whether unmute restores captions, or whether the meeting must be live. Those gaps keep it at minimum-viable completeness.

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

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

There is a single parameter whose schema description is fully covered (100%), including where meeting_id comes from (create_broadcast/join_broadcast). The description adds nothing 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 concrete effect ('Stops captions for this meeting') and scopes it ('only stops transcription'), which resolves the ambiguity of the name 'mute'. It does not name the counterpart sibling (unmute) or distinguish itself from transcript-reading tools like get_transcript/tail_transcript, so differentiation is incomplete but the purpose is clear.

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 to stop captioning, and the 'only stops transcription' clause hints that other bot functions remain active. There is no explicit when-to-use vs unmute, no prerequisites or state requirements, and no when-not guidance.

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

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

With no annotations, the description carries the full burden and does well: it discloses that the host key is held in memory and never stored, that the session persists until close_booth or end_broadcast, and that opening does not broadcast. It does not cover what happens if a booth is already open, whether the browser session times out, or the cost of launching a headless browser.

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

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

Four short sentences, front-loaded with what happens and immediately followed by the key constraint that it is off air. Dense but each sentence carries real information about lifecycle or credential handling.

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, so the description correctly focuses on state and lifecycle, and it covers credential handling, persistence, and downstream effects. The remaining gap is failure/edge behavior (already-open booth, invalid password) that an agent would want before invoking a stateful browser-launching tool.

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

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

Schema description coverage is 100%, so every parameter is already documented, including the 'never stored' note on host_password. The description reinforces the host_password lifecycle but adds nothing about link vs. meeting_id or host_name, so baseline 3 applies.

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

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

States a specific verb and resource ('Opens the host's seat for this broadcast') plus the execution environment ('headless browser on this computer') and the state ('off air'). The closing line 'Opening does not go live' explicitly separates it from the sibling tool go_live.

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?

Names the downstream tools that only function while the booth is open (go_live, play_video, set_start_time, set_visit_link, end_broadcast) and the two terminators (close_booth, end_broadcast), which tells an agent where this sits in the sequence. It stops short of an explicit 'do not call if a booth is already open — check booth_status first' condition.

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 burden and does real work: it discloses the viewer-visible 'Prerecorded' mark, that viewers cannot skip or save, the live/immediate nature, and the single-video exclusivity rule. It doesn't cover failure behavior (e.g., invalid path) or whether the call blocks until the video ends, which keeps it below a 5.

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

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

Three short sentences, zero filler, with the core action front-loaded and the exclusivity/termination rule at the end. Every clause carries information an agent would otherwise have to guess.

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 action tool with no output schema and no annotations, the description covers what it does, its visible side effects, and its stopping counterpart. The main remaining gap is the absence of any mention of what the call returns or how path errors surface, which matters when there is no output schema to fall back on.

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

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

Schema description coverage is 100%, and the schema already explains both 'path' (local file, .mp4/.webm) and 'meeting_id' (from create_broadcast/join_broadcast). The description's phrase 'from this computer' reinforces the path semantics but adds no format or constraint detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource ('Plays a video file from this computer live into the broadcast') plus the audience scope ('for everyone watching'). It explicitly names the sibling that ends the action (stop_video), so an agent can distinguish it without opening a schema.

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

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

Gives clear operational context: it happens 'now' and only 'one video at a time,' with stop_video named as the terminating counterpart. It stops short of routing against other content-sharing siblings such as share_content, so the agent must infer which tool to use for non-video content.

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 burden and does well: it discloses interruption of current speech, that audio is synthesized locally by Kokoro, and that the bot generates no content of its own. It omits whether the call blocks until speech finishes, how concurrent calls behave, and error conditions such as an invalid voice.

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?

Roughly four short sentences, front-loaded with the action and its interruption behavior, followed by the no-auto-answer note and the sibling disambiguation. Every sentence carries distinct information with no repetition of the 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?

For a simple 3-parameter, no-output-schema tool, the description covers purpose, timing semantics, audio provenance, and sibling routing. The remaining gap is return/latency behavior, which is minor for a speak-now action.

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

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

Schema description coverage is 100%, so all three parameters (text, voice, meeting_id) are already documented with examples and constraints. The description adds no additional semantics about parameters, which is acceptable at this coverage level but earns no bonus.

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+resource+mode: 'says this line out loud in the room now,' with scoping detail that it interrupts in-progress speech. It also explicitly separates itself from share_content and send_chat, so an agent can pick it without opening sibling schemas.

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?

Names the alternatives and the axis of difference: 'share_content and send_chat are chat, not speech,' which tells the agent to choose this tool for audible output. It does not spell out exclusions such as muted rooms or meeting-state prerequisites, so it falls short of a full 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?

With no annotations, the description carries the full burden and does substantial work: no join occurs on this call, no mail is sent, the bot joins one minute early by default, a missing end becomes start+8h, the password is persisted but never returned, and non-understood recurrences are refused. Remaining gaps are auth requirements and failure behavior for an unknown link.

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?

Short declarative sentences, front-loaded with what the call does and immediately followed by what it does not do. Mild redundancy around room_password (mentioned at the top and again at the end), but the second mention carries distinct non-return-disclosure value.

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 10-parameter mutation tool with no annotations and no output schema, the description covers defaults, side effects, and secrecy well, but never says what the call returns — an agent has no idea whether it gets a schedule id it will need later for cancel_schedule or update_schedule. No mention of required-field failures or duplicate-link handling either.

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 reinforces a few semantics (room_password is the guest-facing invite password; early_margin overrides the one-minute default) but mostly restates defaults the schema already documents, and says nothing about topic, timezone, or external_id's upsert behavior beyond what the schema states.

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

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

"Stores a join order for a link that already exists" names a specific verb and resource, and the description immediately contrasts with the join-now path ("This call does not join yet"), so an agent can separate it from join_broadcast/join_broadcast siblings without opening a schema. It also pins the scope to pre-existing links, distinguishing it from create_broadcast.

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 negative routing ("This call does not join yet and does not send mail") implies that immediate joining belongs to another tool, but the alternative is never named. Nothing distinguishes this from update_schedule or import_schedule, whose names sit right next to it in the sibling list.

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 does disclose real behavioral facts beyond the schema: the message is attributed to the bot and is not rendered as speech. It omits whether the line persists in the transcript, permission/auth requirements, and rate limits or failure behavior for a mutation.

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 very short sentences, front-loaded with the action, with zero filler. The middle clause 'Same chat channel as share_content' is a fragment that reads slightly awkwardly but still earns its place as a scoping cue.

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 two-parameter write tool with no output schema and no annotations, the description covers identity, channel and non-speech behavior, which is close to adequate. It stops short of stating what a caller gets back or how failures surface, leaving the no-annotation case partly uncovered.

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 both parameters document their own meaning and length bounds, so the baseline is 3. The description adds nothing about the 2000-character cap or how meeting_id is obtained that the schema does not already say.

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 ('Posts a chat line') plus the acting identity ('as the bot'), and explicitly separates itself from two siblings: share_content (same channel, different content type) and say (speech output). An agent can pick this tool without inspecting 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 does not speak (say does that)' gives an explicit when-not and names the alternative tool. There is no guidance on when to prefer send_chat over tail_lines/get_transcript for reading chat, but the main confusion pair (text vs speech) is resolved.

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 so convincingly: persistence across restarts, that a name change restarts the bot, that new pictures apply only to rooms joined from now on, and that a name change is refused mid-room. Missing only what the call returns and how clear_picture interacts with picture_path.

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 tight sentences, front-loaded with the core effect and then the constraints. The final environment-variable sentence is dense but genuinely load-bearing; the only minor cost is the run-on feel of the first sentence.

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 mutation tool with zero annotations and no output schema, the description covers persistence, restart side effects, the room precondition, file constraints, and restart-time overrides. Minor gaps remain around zero-argument calls and argument conflict handling.

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 information beyond the schema: accepted image formats, the 256 KB limit, and the environment-variable precedence that governs these fields. clear_picture's semantics are still only conveyed by the schema, keeping it below 5.

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

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

The description names the exact verb and both resources it mutates — the bot's display name and its avatar picture — plus the accepted file formats and size ceiling. Nothing else in the sibling list touches bot appearance, so an agent can distinguish it immediately 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 supplies a real precondition (the change is refused while the bot is in a room) and routes the agent to end_meeting first, and it flags that GIFOS_BOT_NAME / GIFOS_BOT_PICTURE override these values at next start. That covers when-not and precedence well, though it doesn't discuss calling it with no arguments or the relationship between picture_path and clear_picture.

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 the user-facing effect (viewers see a countdown and calendar link), the clear/reset semantics, and a prerequisite state (booth must be open). It does not cover permission requirements, idempotency, or what happens if the start time is set after go_live.

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 primary effect, then the clearing behavior and precondition. No filler sentences.

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

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

For a 3-parameter tool with full schema coverage and no output schema, the description supplies what structured fields cannot: viewer-visible consequences and the booth prerequisite. The only real gap is the timezone argument's interaction with the start string, which the schema largely handles.

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 start, timezone and meeting_id in detail. The description's "empty start to clear it" merely restates the schema's "or empty to clear" and says nothing about the timezone parameter — baseline 3 applies.

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

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

States a specific verb and resource (set the start time) plus the exact viewer-visible outcome: a countdown and Add to calendar entry. That scoping distinguishes it from scheduling siblings like schedule_meeting, though no sibling is named 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 a concrete precondition ("Needs the open booth") and an explicit alternate use ("Pass an empty start to clear it"), so an agent knows the context for calling it. It stops short of naming when to prefer a different tool or what to do if the broadcast is already live.

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 the meaningful traits: the link is public ("every viewer sees"), where it is rendered, and that empty clears it. It omits permissions/roles required and whether the prior link is overwritten, which keeps it short of a 5.

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

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

Three short sentences, zero filler, with the effect stated first and the precondition last. Every sentence contributes a distinct fact.

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 mutation with fully described schema and no output schema, the description supplies the effect, the clearing behavior, and the prerequisite. A note on required role/open-booth failure behavior would close the remaining gap.

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

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

Schema coverage is 100% and both parameters are documented in-schema, including the https constraint and the empty-to-clear convention. The description restates the clear semantics but adds no format or validation detail beyond the schema, so baseline 3 applies.

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

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

Names a specific verb and resource (set the Visit link) and describes exactly where the value surfaces — on the picture and the ended card — which lets an agent tell it apart from the surrounding booth/broadcast tools. No explicit sibling contrast, but the operation 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?

"Pass an empty url to clear it" gives the clearing recipe, and "Needs the open booth" states a concrete precondition for invocation. Clear usage context, though it never names an alternative tool or says what to do if the booth is closed.

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. It discloses the important behavioral fact that the message is posted under the bot's identity and lands in the same channel as send_chat, but says nothing about delivery guarantees, permission/prerequisite requirements (bot must be in the meeting), length limits, or failure modes.

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

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

Three short sentences, front-loaded with the core action, and the parenthetical exclusion is compact. Minor waste in the parenthetical phrasing ('say does that') but 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?

For a two-parameter tool with a fully documented schema and no output schema, the description covers action, identity, and channel. The remaining gap is the unresolved relationship with send_chat, which an agent would want resolved before picking between the two.

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

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

Schema description coverage is 100%, so both parameters are already documented including the 2000-character limit and where meeting_id comes from. The description adds no syntax or format detail beyond what the schema provides, so baseline 3 applies.

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

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

States a specific verb and resource: posts text into the meeting chat as the bot, and pins down the channel identity by tying it to send_chat. It does not, however, explain how it differs from send_chat despite claiming the same channel, which leaves the closest sibling ambiguous. The title also promises link sharing that the description never addresses.

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 negative routing ('does not speak — say does that', 'does not share a screen'), which is genuinely useful for excluding siblings. But it never states when to choose this over send_chat, the one tool it explicitly says shares the same channel, so the key selection decision is left to inference.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it does state read-only semantics: it does not join another browser and does not change the meeting. That is a real behavioral claim beyond the schema. It leaves minor gaps, such as what happens if no page is open or whether the image is a fresh capture.

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

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

Three short clauses in one pass: what is returned, what it does not do, and the alternative. The payload description is front-loaded and no sentence is filler.

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

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

For a one-parameter read tool with no output schema, the description covers the return type (image content plus a people list), the side-effect profile, and the sibling alternative. An agent has everything needed to call it correctly.

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

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

Schema coverage is 100% and the single meeting_id parameter is documented in the schema with its origin (create_broadcast or join_broadcast). The description adds nothing about the parameter, 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 name 'snapshot' alone is ambiguous, but the description immediately specifies the payload: the participant list plus a PNG of the already-open Meeting Bot page, returned as image content. It also distinguishes itself from get_meeting_state, so an agent can choose 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?

'get_meeting_state is the same people list without the picture' gives a clear routing rule to the sibling tool. It does not state explicit exclusions (e.g. when the picture is not wanted or when the snapshot would be stale), so it falls short of full when/when-not guidance.

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

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

No annotations are supplied, so the description carries the full burden of behavioral disclosure. It does disclose useful behavior: it is a point-in-time ('right now') read that surfaces browser liveness, active GifOS instance, and room membership. It stops short of stating that it is side-effect-free, whether it is cheap to poll, or whether it can fail when the browser is down, which matters for a zero-annotation 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?

A single sentence that front-loads the most important check (is the browser up) and enumerates the remaining two facts without filler. Nothing could be removed without losing 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?

With no output schema and no annotations, the description is the only source of truth, and it does list the three things returned. But the return shape is not structured (names of the GifOS identifier or room list are undefined), and the proximity of several other *_status tools leaves the agent unsure when this generic 'status' is the right entry point.

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

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

The tool takes no parameters and the schema is an empty object, so there is nothing to disambiguate. Baseline for a zero-parameter tool applies.

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

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

The description names the concrete resource it reports on: whether the headless GifOS browser is running, which GifOS instance is in use, and which rooms the bot currently occupies. That is far more specific than the bare name 'status'. It does not, however, contrast itself with the several sibling status tools (capacity_status, meeting_status, booth_status), so an agent cannot tell from this text alone which one answers its 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?

There is no guidance on when to call this versus the other status-like siblings, no mention of preconditions (for example, that it is useful when a join or broadcast appears broken), and no exclusions. The agent must infer usage entirely from the three facts the tool reports.

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 bears the full disclosure burden. It does add real behavioral context — the broadcast is left open, so this is a scoped stop, not a teardown — but it says nothing about what happens if no video is currently playing, whether the stop is immediate for all viewers, or error behavior.

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

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

Two short sentences, front-loaded with the action and followed by the key state consequence. No filler, though it is perhaps terse for a tool with no annotations.

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

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

For a single-parameter, no-output-schema action tool the description covers the essentials: what stops, the counterpart that started it, and the resulting broadcast state. The main gap is the no-op / error case when nothing is playing.

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

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

Schema coverage is 100% and the single meeting_id parameter is fully documented in the schema, including its provenance (create_broadcast or join_broadcast). The description adds no parameter detail, which is acceptable since the schema already does the work.

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

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

Specific verb (stops) plus resource (the video), tied directly to the sibling play_video that started it, and the phrase 'the broadcast stays open' implicitly differentiates it from end_broadcast. An agent can identify the operation 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?

Usage is implied by the reference to play_video (call it after starting a video) and by 'the broadcast stays open', which hints that end_broadcast is a separate action. Neither the when-not condition nor the end_broadcast alternative is stated explicitly.

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 ordering, event categories, and the cursor handoff, but says nothing about whether the call blocks/streams, how many events are returned per call, or what an empty result means — meaningful gaps for a 'tail' style 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?

Two short sentences, zero filler, with the core purpose front-loaded and the pagination instruction second. Every clause earns its place.

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

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

With one optional parameter, no annotations, and no output schema, the description should clarify the return shape more than it does — it names a few event types and implies a 'next' cursor but not the batch size or whether other event types appear. Adequate but with clear gaps for a tailing tool.

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

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

Schema description coverage is 100% and the schema already says 'Pass the previous next, or omit to read from the start', so the description's cursor note largely repeats structured data. Baseline 3 applies; no extra semantics such as bounds or batch-size interaction are added.

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 resource and scope: ordered events for the whole connector, and names concrete event types (capacity.near, capacity.reached, capacity.cleared). It does not explicitly distinguish itself from siblings like tail_lines or tail_transcript, though 'whole connector' implies broader scope than those.

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?

'Pass next back as since' gives concrete continuation guidance for pagination, which is useful. However, there is no statement of when to use this versus tail_lines/tail_transcript, nor any exclusion or prerequisite, so usage is only implied.

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 does disclose the scope default (omitting meeting_id reads every meeting), which is useful behavioral context. But it says nothing about ordering, result caps, or whether the call blocks — critical for a tool whose name implies streaming/polling, especially with a sibling named wait_lines.

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

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

Three short sentences with no filler, and the core payload is front-loaded. The clipped, almost fragmentary phrasing costs a little readability but wastes nothing.

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?

All three parameters are optional with full schema documentation and there is no output schema, so the bar is moderate. Still missing is what a returned 'line' contains, whether results are ordered by seq, and how this differs from wait_lines for an agent deciding between them.

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 baseline is 3. The description adds meaning beyond the schema by explaining what omitting meeting_id does (reads all meetings), something the schema field text does not state. It otherwise restates the since and kinds semantics already documented.

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 concretely what is returned (stored speech, chat, and spoken lines above a given seq) and explicitly contrasts with tail_transcript. It doesn't differentiate from other tailing siblings such as tail_events or wait_lines, so it falls short of full sibling disambiguation.

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?

'Omit meeting_id to read every meeting' and 'tail_transcript is speech and spoken for one meeting only' give one real routing rule and one alternative. However, the far more consequential question for a 'tail' tool — when to poll this repeatedly versus call wait_lines — is never addressed.

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 burden and does real work: it discloses that the call is valid during and after the meeting, that chat is excluded, and what the kind values mean. It omits ordering guarantees, page sizes, and whether it blocks versus returns what exists now — relevant since wait_lines exists as a sibling.

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

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

Front-loaded with what is returned and the filter, then the exclusion and the resource equivalence. Dense but every sentence carries information; a small amount of overlap with the schema on the since semantics keeps it from a 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?

No output schema and no annotations, so the description must characterize the return value, which it does by naming the line kinds, the seq field, and excluding chat. It stops short of describing ordering or the shape of a line beyond kind, which is the main remaining gap for a tailing tool.

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

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

Schema coverage is 100% and both parameter descriptions are already documented, including the seq-greater-than semantics and the omit-or-0 default. The description restates the since behavior rather than adding new syntax or edge-case guidance, so it matches the baseline.

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

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

States a specific resource (speech and spoken lines for one meeting) plus a precise incremental filter (seq greater than since), and defines the two kinds. It explicitly separates itself from tail_lines by noting chat is not included, so an agent can distinguish it from siblings 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?

Names tail_lines as the alternative and gives the conditions that favor it (chat included, kind filtering, all meetings at once), and clarifies it works both during and after the meeting. It does not address the closest sibling, get_transcript, so the choice between live-tailing and fetching a full transcript is left to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden, and one sentence is not enough: it does not say whether the call is idempotent, what happens if transcription is already enabled, whether the bot must be in the meeting first, or whether the meeting_id must be live. It discloses the state effect and nothing more.

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

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

A single front-loaded sentence with no filler; every word contributes to identifying the operation and its scope.

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

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

With one fully documented parameter and no output schema, the description is minimally sufficient, but as an unannotated mutation tool it leaves open idempotency, precondition, and error behavior that an agent would want before calling.

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

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

Schema coverage is 100% and the schema itself explains meeting_id including its origin (create_broadcast or join_broadcast). The description adds no parameter detail beyond that, so the baseline 3 applies.

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

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

States a specific verb ('turns transcription back on') and the resource scope ('for this meeting'), and the 'back on' framing implicitly distinguishes it from the sibling 'mute'. It does not explicitly name mute as its counterpart, but the purpose 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?

There is no explicit statement of when to call this versus alternatives or what prerequisites apply; usage is only implied by the name and the 'back on' wording, which suggests re-enabling after a mute. An agent can infer it but is not told.

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 usefully discloses blast radius (omitting occurrence rewrites the whole future series), that existing transcripts are not rewritten, and an auth constraint (admin password is not accepted). These are non-obvious traits beyond the schema. Gaps remain on permissions/ownership requirements and whether changes are reversible.

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, each carrying real information with no filler. It is not front-loaded with the core purpose, which slightly weakens orientation for an agent scanning descriptions.

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 10-parameter mutation tool with no annotations and no output schema, the description covers the highest-risk behavior (series-wide edits, transcript immutability) but omits the response shape and the permission model. Adequate but with clear gaps.

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

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

Schema coverage is 100%, so all ten parameters are already documented, including occurrence's omit/set semantics. The description mostly restates the occurrence rule and hints at room_password behavior via the admin-password note, adding little beyond the schema. Baseline 3 is appropriate.

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

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

The description never states plainly that this tool updates an existing scheduled meeting; it opens directly with occurrence-scoping semantics. The verb+resource come only from the name and title, and no sibling (cancel_schedule, import_schedule, schedule_meeting) is named or distinguished. Purpose is inferable but not articulated in the description itself.

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

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

It gives a clear conditional rule for the occurrence parameter (omit = whole future series, set = single occurrence), which is genuine usage guidance. However, it offers nothing on when to use update_schedule versus cancel_schedule or schedule_meeting, and no prerequisites for editing an existing schedule.

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 well: it discloses the blocking behavior, the cursor pattern, the timeout fallback, and the to_bot flag on returned lines. It leaves out error behavior and whether the operation is strictly read-only, but the core behavioral model is clear.

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 dense sentences, front-loaded with the return condition and immediately followed by the loop/cursor guidance. No wasted wording.

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 blocking wait tool with no output schema, the description adequately explains what is returned (lines, next, to_bot) and how to continue the loop. It could be more complete about the returned line shape and ordering, but nothing critical 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 the baseline is 3. The description still adds real meaning beyond the schema by explaining the cursor convention ('pass the returned next as since') and the to_bot marker in results, which the schema alone does not convey.

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

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

The description names a specific verb and resource ('Returns as soon as there is a line with seq greater than since') and explains the blocking-wait semantics clearly. It does not explicitly contrast itself with the sibling tail_lines, so an agent must infer the difference from the 'use it in a loop' phrasing.

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

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

It gives clear usage context: 'Use it in a loop to follow a live room with the least delay: pass the returned next as since.' That tells the agent when this tool is appropriate. It stops short of naming tail_lines as the non-blocking alternative or stating when not to use it.

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