meeting-agents

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

With no annotations provided, the description carries the full burden of disclosing behavior. It clearly identifies the tool as an explainer about Mainroom, which implies it is read-only and has no side effects. It also specifies the scope of content covered (voice, slides, live demos, research, memory, follow-up emails), giving the agent a solid sense of what calling it will provide.

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

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

The description is two sentences and front-loads the core identity of the tool with 'What Mainroom is'. It packs relevant detail about capabilities and workflows without excessive fluff, though the first sentence is somewhat list-heavy. It is concise enough for an informational tool with no parameters.

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

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

The tool has no parameters, no output schema, and low operational complexity, so the description does not need to explain return values or parameter semantics. It adequately covers what the tool explains and mentions the related sibling actions, giving an agent enough context to decide when to call it. It could be slightly more explicit about the expected output (e.g., that it returns explanatory text), but the current description is sufficient.

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

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

The input schema has zero parameters and schema description coverage is 100%, so there is no parameter information to supplement. The baseline for a no-parameter tool is 4, and the description appropriately uses its space to explain the tool's purpose rather than discussing parameters.

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

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

The description clearly defines the tool as an informational resource explaining what Mainroom is and how its workflows operate. It distinguishes itself from sibling action tools by explicitly covering topics like dispatching the demo agent, joining meetings, and sending a delegate. The verb 'Explains' gives a concrete function rather than a vague or tautological 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 makes it clear this is a background/overview tool by saying it explains how humans invite agents and how AI assistants can dispatch, join, or delegate. It references the sibling workflows without explicitly stating when not to use them, but the contrast between explaining and doing is evident. A more explicit 'use this when you need orientation before taking action' would have earned a 5.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses significant traits: the delegate joins as a named participant, hands decisions back to the user, sends a report afterwards, requires an API key, and returns a session id that can be polled via meeting_status. This goes well beyond a minimal 'sends a delegate to a meeting'. Minor gaps like error behavior or failure handling keep 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?

The description is compact and efficient despite its length: it opens with the action label 'DELEGATE', packs the behavioral contract into a sentence, then covers the report, API key, return value, and usage triggers without redundancy. Every sentence contributes practical 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?

For a complex live-meeting tool with no output schema, the description is quite complete: it states prerequisites, the delegation flow, the post-meeting report, and how to track progress via meeting_status. It lacks explicit error-handling or preconditions like meeting accessibility, but overall an agent can determine how to invoke and monitor 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 input schema already covers 100% of parameters, so the baseline is 3. The description adds meaningful narrative semantics: the brief is 'relays their positions from the brief', questions are 'asks the questions they need answered', and meeting_url is 'a live meeting'. It also points to where the API key can be found. It doesn't elaborate on voice/persona_name/rehearse, but the schema already documents those.

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

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

The description opens with 'DELEGATE: send the user's own stand-in into a live meeting they can't attend', giving a specific verb and resource that immediately distinguishes it from the sibling tools. It clearly explains the delegate's behavior (introduces itself, relays the brief, asks questions) and is not a tautology of the tool name.

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 ends with explicit use-case phrases: 'Use when your user says "cover this meeting for me", "I can't make the 3pm", "send someone in my place"' — concrete triggers for selection. It also notes the API key prerequisite and how to follow up via meeting_status. It does not name any alternative tool for when not to use it, but the context is clear.

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

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

No annotations are provided, so the description carries the burden. It clearly implies a read-only operation by describing it as retrieving history and recorded data, with no mention of side effects or mutations. This is transparent enough for an agent to infer safety.

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

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

The description is a single paragraph with a clear structure: what it returns, example queries, and a usage hint. It is slightly verbose (e.g., the leading 'HISTORY:' label) but remains focused and under 100 words.

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

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

The description explains the output types (open commitments, follow-ups, timeline summaries) and mentions the sessions parameter for timeline depth. It does not include potential errors or return format details, but given the absence of an output schema, this level of detail is adequate.

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

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

The schema already covers all three parameters, but the description adds useful context: relationship can be a key from list_relationships, and sessions controls the timeline depth. This supplements the schema without redundancy.

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 (history recorded by Mainroom agents) and the scope (per account, team, or person). It also provides concrete example queries ('where are we with Acme') that make the purpose immediately actionable.

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

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

The description explicitly says 'Use it to answer...' and lists example use cases, giving clear guidance on when to invoke this tool. It does not contrast it with sibling tools like list_relationships, but the examples are sufficient for typical usage.

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

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

With no annotations provided, the description carries the full behavioral burden and meets it thoroughly. It discloses the division of labor (agent supplies name/persona, Mainroom supplies the body), latency ('appears in the meeting lobby within ~a minute'), the human-admission requirement, and ephemerality (no account, no memory, nothing emailed afterwards) — including in-meeting capabilities and limitations.

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

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

The core purpose is front-loaded via the 'EMBODIMENT:' label, and the description flows logically: purpose, capabilities, logistics, state behavior, usage triggers. It is information-dense with no wasted sentences, though the opening 'AS YOURSELF (or as a persona you define)' is mildly redundant with the later 'You supply the name and the persona instructions.'

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

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

Given no output schema, the description covers the operational contract well: what the agent can do in the meeting, how admission works, timing, and what persists. The only gap is the lack of any statement about what the function returns synchronously (success indication, error on rejection), which is relevant since no output schema exists to fill that in.

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 documents all five parameters with meaningful descriptions (e.g., display name, persona instructions, intro message, voice enum, meeting URL). The description adds mild framing — 'You supply the name and the persona instructions' — that reinforces agent_name and instructions, but doesn't substantially go 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 opens with a specific verb+resource ('join a live meeting AS YOURSELF') and expands into concrete capabilities: a camera tile, a voice, presenting slides, showing images, reading/posting chat. It clearly differentiates from siblings about_mainroom, list_agent_templates, and send_demo_agent, which are informational/list/send operations rather than live participation.

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

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

Provides explicit trigger phrases ('join my call', 'be in the meeting') and a task-based condition ('you need to talk to people in a live meeting to complete a task'). It does not name alternative tools or state when-not-to-use scenarios, but the usage context is unambiguous and operationally useful.

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. It adds the 'built-in' scope, indicating custom agent templates are not included, which is useful. However, it doesn't mention whether the result is cached, live, or anything about side effects, though 'list' strongly implies read-only 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?

A single, front-loaded sentence with no filler. The examples add useful detail without bloating the description.

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 list tool with no output schema, the description provides enough information to call the tool correctly and anticipate the result. A mention of the return format would be nice, but the verb 'List' and examples sufficiently convey the expected output.

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, and the schema confirms an empty object. The description compensates by explaining what will be listed, which is all that is needed. Baseline of 4 for no-parameter tools is appropriate.

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

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

The description states a specific verb ('List'), a clear resource ('Mainroom's built-in agent types'), and provides concrete examples (facilitator, timekeeper, etc.). This distinguishes it from sibling tools like join_meeting_as or send_demo_agent, which clearly perform different actions.

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 context is clear: use this tool when you need to know what built-in agent types are available. It doesn't explicitly compare against siblings, but none of the siblings are listing tools, so the appropriate use is implied. No exclusions are needed.

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 mentions the API key requirement but does not disclose whether the operation is read-only, has side effects, or modifies any data. The 'list' verb implies a safe operation, but that is not explicitly stated.

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 longer than necessary but well-structured, front-loaded with 'HISTORY:' and then enumerating the returned data. The trailing note about get_relationship_history is relevant and placed appropriately. Slight redundancy with the schema (e.g., api_key format) is acceptable.

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 there is no output schema, the description gives a reasonable picture of what is returned (session counts, last met, commitments/open questions/risks). It also points to the companion detail tool. It could be more explicit about the exact return shape or ordering, but it is sufficient for a list operation.

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

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

Schema coverage is 100% for the two parameters. The description adds useful context beyond the schema by explaining that the api_key is shown on the History page and clarifying the query filter applies to accounts, teams, or people. This enhances the schema's bare field descriptions.

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

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

The description clearly states the tool lists customer accounts, recurring team meetings, and people the user's agents have met with, including session counts, last meeting time, and outstanding commitments/questions/risks. It also distinguishes itself from the sibling get_relationship_history by noting that tool provides detail.

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 'HISTORY:' prefix and the phrase 'Follow with get_relationship_history for the detail' explicitly indicate when to use this tool versus the sibling detail tool. It also notes the requirement for the user's API key, though it could more explicitly state 'use this for an overview'.

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 of behavioral disclosure. It reveals that the tool reports live or recorded meeting state, whether the bot is still in the lobby, and that it requires the user's Mainroom API key. It does not explicitly say whether it mutates anything, but the 'follow/status' framing strongly implies a read-only observation tool.

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

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

The description is front-loaded with 'FOLLOW A MEETING' and every clause adds relevant information: what data is returned, how to list sessions, and the required API key. It is somewhat long and dense, but not wasteful given the tool's breadth.

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 compensates by enumerating the expected outputs: transcript, summary, answers, decisions, commitments, and lobby status. It also covers authentication and the no-session listing behavior. It lacks format details or error cases, but is sufficient for selecting and invoking the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds only minor context beyond the schema: it clarifies the relationship to delegate_to_meeting for session ids and repeats the omit-to-list behavior already documented in the session parameter. It does not meaningfully change parameter understanding.

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

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

The description opens with a specific verb-resource pair, 'FOLLOW A MEETING', and enumerates exact contents: last transcript lines, running summary, question answers, decisions, commitments, and lobby status. This clearly differentiates it from sibling tools like delegate_to_meeting or join_meeting_as by focusing on observing an agent's live/recorded view of a meeting.

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

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

The description gives clear usage context: call with a session id to follow a meeting, or omit it to list recent/live sessions, and notes that session ids come from delegate_to_meeting. It does not explicitly state when not to use this tool or name alternatives, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, and it delivers: the agent appears in the lobby within ~a minute, a human must admit it, it introduces itself, answers by voice, presents slides, and can run a live browser demo. Missing are failure/error behavior (invalid URL, not admitted), whether the call is asynchronous, and how the agent is removed — so not a 5, but far above the minimum.

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

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

The description is front-loaded with the core action, then packs platforms, timing, lobby behavior, capabilities, usage guidance, and the account note into three sentences. It is slightly long but every sentence earns its place; nothing is wasted.

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

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

For a single-parameter tool with no output schema and no annotations, the description is largely complete: it covers what happens on invocation, timing, dependency on a human, capabilities, and prerequisites. The notable gaps are the return value/confirmation the caller receives, error cases, and agent lifecycle (how long it stays / how it is removed), which keep it from a 5.

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

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

Schema coverage is 100%, so the baseline is 3. The description reiterates the supported URL platforms (Google Meet, Teams, Zoom, Webex) that the schema examples already encode, adding only the 'live meeting' framing and 'Full join URL' emphasis. It adds no meaningfully new semantics 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 a specific verb ('Send'), a specific resource ('Mainroom's open demo agent'), and a target ('a live meeting RIGHT NOW'), and enumerates exactly which platforms it supports. This clearly distinguishes it from siblings like about_mainroom, join_meeting_as, and list_agent_templates without needing to open 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 gives an explicit when-to-use condition: 'Use when your user wants an AI participant in a meeting that is happening now.' It also adds a prerequisite note ('No account needed') and the live-meeting requirement, which help an agent decide between this and the meeting-related sibling. It does not explicitly name alternatives or when-not-to-use conditions, but the context is clear enough.

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