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

Annotations already declare readOnlyHint and destructiveHint, so the bar is lower. The description adds value by explaining the groups stream behavior and that each post names its group, which is not obvious from the schema alone. No contradiction with annotations.

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, front-loaded with the primary purpose and then the groups variant. Every sentence earns its place; the only minor redundancy ('Read-only') is a single word and not wasteful.

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, combined with the rich schema descriptions and annotations, adequately covers this read-only list tool. It does not describe the return format, but no output schema exists and the schema already explains parameter effects, so this is acceptable.

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 documents all four parameters thoroughly. The description adds minimal extra meaning; it reinforces the source parameter but does not introduce new semantics beyond what the schema already provides.

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

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

The description clearly states the tool reads the logged-in account's own Facebook feed, using a specific verb ('Read') and resource. It also distinguishes the 'groups' source variant, which sets it apart from sibling tools like read_post or search_facebook.

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 explanation of 'source: groups' gives clear context for choosing between the home timeline and the combined groups feed. However, it does not explicitly mention alternatives or when not to use this tool, stopping short of a 5.

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

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

The description says the tool 'Discard[s]' an action and that the token 'can never be used,' implying a permanent, state-changing effect, yet annotations declare readOnlyHint=true and destructiveHint=false. This directly contradicts the description's side-effect profile, making the behavior dangerously unclear.

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 only two sentences and is front-loaded with the core action and consequence. Every word earns its place, with no redundant 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?

Given the tool's single parameter, clear use case, and absence of an output schema, the description provides sufficient context for most scenarios. However, the contradiction between the description's irreversible effect and the read-only annotation creates a significant gap in overall comprehension.

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 lone parameter (confirmation_token) is already fully documented in the schema as 'Token of the staged action to discard.' The description adds no further parameter-level detail beyond echoing the token concept, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Discard') and a clear resource ('a staged write action'), explicitly stating the irreversible consequence ('so its token can never be used'). It clearly distinguishes this from sibling tools like confirm_action and list_pending_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 description provides a clear use case ('Use this when the user rejects or changes a draft'). However, it does not explicitly state when not to use the tool or name alternative tools, so it falls short of a perfect score.

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

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

Even though annotations already declare readOnlyHint=true and openWorldHint=true, the description adds valuable behavioral details: it launches the browser on first use, never interacts with login flows, and if a security challenge appears, it reports it and leaves the window open for the user. This goes well beyond the structured annotations.

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 three sentences, front-loaded with the primary purpose. Every sentence adds distinct value: what it reports, side effects (browser launch), and boundaries (never logs in/challenge handling) plus the explicit usage directive. No wasted 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?

For a zero-parameter, no-output-schema check tool, the description covers all necessary context: the exact question it answers, its side effects, its non-actions, and when to run it. There is no ambiguity; an agent can correctly invoke it without further information.

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

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

The tool has zero parameters, so the schema is trivially 100% covered. Per the rubric, 0 params yields a baseline of 4. The description adds no parameter-specific meaning, but none is needed.

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 'Report whether the persistent browser profile is logged into Facebook,' a specific verb ('Report') and resource ('persistent browser profile') that clearly states the tool's function. It is also distinguished from siblings like 'open_facebook_login' by explicitly stating it never logs in.

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

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

The description gives explicit when-to-use guidance: 'Run this before anything else in a session.' It also provides when-not-to-use context by stating it never logs in and never answers security challenges, implying that other tools (e.g., open_facebook_login) are needed for those actions.

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

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

The description goes well beyond the annotations. While the annotations indicate readOnlyHint=false, the description adds critical behavior: tokens are single-use and expire, and the verification result may be 'unverified' meaning the action 'may or may not have gone through' and must not be reported as success. This is exactly the kind of nuanced behavioral context an agent needs. No contradiction with annotations.

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 with no filler. It front-loads the core function ('Execute a previously staged write action'), then packs essential usage constraints and result interpretation into a compact second sentence. 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?

Despite having no output schema, the description explains what the result reports ('verified' vs 'unverified') and how to handle the ambiguous case. It covers prerequisites (user approval of exact content), token usage constraints, and the scope of the tool ('only tool that changes anything'). This is sufficiently complete for a tool with two simple parameters and a nuanced side effect.

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 both parameters, so the baseline is 3. The description adds value by explaining the token lifecycle (single-use, expires) and the verification outcome associated with the confirmation_token. It also implies the fingerprint is tied to the staged payload. This supplements the schema descriptions without fully re-explaining each parameter, so a 4 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 function: 'Execute a previously staged write action.' It also identifies the exact resource (previously staged actions) and distinguishes the tool from siblings by noting it is 'the ONLY tool in this server that changes anything on Facebook.' This is a specific verb+resource pairing with strong differentiation.

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

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

The description provides explicit when-to-use guidance: 'Call it only after the user has seen the preview and explicitly approved that exact content.' It also implies when not to use by stating the tool is the only one that changes anything, leaving staging to sibling tools. Token expiry and single-use behavior are also stated as usage constraints.

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

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

The description goes beyond the annotations (readOnlyHint=false, destructiveHint=false) by detailing the staging behavior: it validates attachments, builds a preview, and returns a confirmation_token. It also discloses that nothing is published and that user approval is required before confirm_action. These are significant behavioral traits not present in the structured annotations.

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 three sentences long, front-loaded with the core purpose, and every sentence adds meaningful context (staging, no publish, validation/preview/token, approval flow). There is no redundant repetition of schema or annotations, making it highly efficient.

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

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

Despite lacking an output schema, the description explains the key return value (confirmation_token) and the workflow (preview then confirm). It covers the tool's main behavioral contract, including the validation step and the explicit requirement for user approval. The sibling tools include confirm_action, which the description correctly references as the follow-up, making the tool's role in the overall flow 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 the baseline for this dimension is 3. The description adds valuable semantics by stating 'optionally with one local image or video', which clarifies that image_path and video_path are mutually exclusive—a nuance not enforced by the schema. It does not discuss require_confirmation, but the schema already covers that. This added nuance justifies a score above 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?

The description opens with 'Stage a new post on your own timeline', which is a specific verb ('stage') and resource ('post on your own timeline'). It clearly differentiates from sibling tools like post_comment (commenting) and share_post (sharing) by emphasizing the staging aspect. The phrase 'does NOT publish anything' further disambiguates it from a direct publishing tool.

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 states when to use the tool: to stage a post for later confirmation. It provides a clear when-not ('does NOT publish anything') and a direct next-step action ('call confirm_action only after explicit approval'). This is explicit guidance beyond a vague context.

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

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

Annotations already indicate read-only and non-destructive, but the description adds valuable behavioral detail beyond that: it does not navigate, and it enumerates the output composition (tag, attribute names, text length, preview). This gives the agent a reliable mental model of what the tool will do and return.

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, front-loaded with the primary function, then use case, then a critical caveat. Every sentence carries information and there is no fluff or repetition.

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 maintenance/diagnostic tool with 4 well-documented parameters, no output schema, and strong annotations, the description is sufficient. It explains what the tool reports, when to use it, and a critical constraint (does not navigate). No essential context 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 description coverage is 100% (all 4 parameters have descriptions). The tool description itself does not revisit parameter details, which is acceptable because the schema fully documents each parameter. It earns the baseline 3; no additional parameter semantics are needed.

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

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

The description uses a specific verb ('Report') and resource ('page the browser is currently showing'), and details exactly what is reported (match counts, tag, attribute names, text length, preview). It clearly distinguishes itself from siblings by framing the tool as a way to fix selector files against real markup after a redesign, rather than guessing.

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

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

It provides a clear when-to-use context: 'Use this to repair src/facebook/selectors.ts against real markup after a Facebook redesign, instead of guessing.' It also instructs on a prerequisite ('point the browser somewhere with a read tool first') and states the tool does not navigate. However, it does not explicitly name any alternative tool or exclusion criteria, so it stops 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?

The description complements the readOnlyHint annotation by clarifying it does not generate text or post anything, and returns a brief for the agent to use. This adds behavioral context beyond the annotations without contradicting them.

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, front-loaded with the core purpose and output, and clearly states non-behaviors without waste. Every sentence 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?

Despite no output schema, the description adequately describes the brief's contents (post text, context, existing comments). It could mention login prerequisites, but sibling tools like check_facebook_session cover that context, so it is sufficiently complete for a simple 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 the baseline is 3. The description does not add specific meaning to parameters like tone or intent beyond the schema, but it implicitly frames them as inputs to the brief, maintaining 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?

The description clearly states the tool opens a post and returns a brief containing post text, context, and existing comments, explicitly distinguishing it from generating or posting. This specific verb+resource+scope differentiates it from siblings like read_post and post_comment.

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 use: before writing a reply, to gather needed information and avoid repeating existing advice. It explicitly notes the tool does not post, distinguishing it from post_comment, but does not name alternatives like read_post or read_comments.

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

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

Annotations already mark readOnlyHint=true and destructiveHint=false; the description reinforces these with 'Read-only — it finds leads, it does not contact anyone' and adds meaningful behavioral details: how scoring works (relevant topic + asking for help), penalties for self-promotion and resolved threads, and the demand/supply group distinction.

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 long but information-dense and front-loaded with the most actionable instruction ('Omit group_urls to sweep...'). The 2026-08-01 anecdote is illustrative but could be trimmed; overall, nearly every sentence 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?

Even without an output schema, the description explains what the tool returns (ranked leads with plain-English reasons), the scoring criteria, group selection strategy, and its read-only safety profile. It fully covers the tool's complexity and leaves no major 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 baseline is 3. The description adds meaningful strategic context for key parameters like group_urls ('Omit to sweep the combined feed... fastest way') and search_terms ('Much faster, but only finds what Facebook's search surfaces'), but most parameter semantics remain in the schema descriptions.

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

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

The description clearly identifies the tool's action: scanning Facebook Groups and returning posts likely to be genuine service requests, ranked with plain-English reasons. It distinguishes itself from siblings like search_in_group and browse_feed by emphasizing cross-group lead scoring and demand-side targeting.

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 explicitly directed: omit group_urls for a combined feed, target demand-side groups rather than developer/freelancer groups, and use search_terms for faster but limited search. A concrete example ('a 24K-member WordPress *developer* group returned zero leads') reinforces 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.

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

Annotations already declare readOnlyHint and non-destructive, so the description's 'Read-only' adds no new safety info. However, it does disclose that it returns a 'sample' of comments, a behavioral limitation not captured by annotations or schema, which is valuable context.

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

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

The description is two concise sentences that front-load the core functionality and then provide a use case. Every sentence earns its place with no redundancy or fluff.

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

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

Given the tool's simplicity (2 parameters, no output schema) and strong annotations, the description provides sufficient context: what it returns, when to use it, and its read-only nature. It could mention return format details, but the schema and annotations cover the essentials.

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

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

Schema description coverage is 100%, with both post_url and comment_sample having clear descriptions. The tool description adds no extra parameter meaning, so the baseline of 3 is appropriate since the schema does the heavy lifting.

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 retrieves a post plus a sample of its comments in a single call, using the specific verb 'get' and resource 'post details'. This distinguishes it from siblings like read_post and read_comments, which focus on individual components.

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 to use this when deciding whether a post is worth replying to, providing a clear use case. It does not explicitly name alternatives or exclusions, but the context strongly implies this is the go-to for a quick post+comments overview, which is sufficient.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds that the actions are 'staged' with previews and expiry times. This provides useful context beyond the annotations, though it could mention behavior like empty lists or ordering.

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 one sentence of 15 words, front-loaded with the action and resource. Every word adds value, with no redundancy beyond the repeated 'Read-only' which matches 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 simple no-parameter read-only list tool, the description is complete. It specifies what is returned (previews and expiry times) and the context (staged actions), and sibling tools complete the workflow picture. No output schema is present, but the description adequately conveys return content.

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

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

The tool has zero parameters, and the schema coverage is 100% (vacuously). The description does not need to explain parameters, and the baseline for zero-parameter tools is 4.

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

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

The description uses a specific verb ('Show') and identifies a clear resource ('write actions that are staged and waiting for confirmation'), including details like previews and expiry times. This distinguishes it from sibling tools like 'confirm_action' and 'cancel_action'.

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 clearly implies when to use it: to review staged write actions before confirmation. It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to understand its role in the workflow.

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

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

Beyond the readOnlyHint annotation, the description reveals important behavioral traits: it 'only watches for the session to go live,' reports immediately if already logged in, and on timeout 'the window stays open and their progress is not lost.' No contradictions with annotations.

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

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

Three sentences, front-loaded with the main action, and each sentence serves a purpose: launch, wait, safety, and timeout handling. No filler or 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?

For a single-parameter tool with no output schema, the description covers all relevant scenarios: success, already logged in, timeout, and fallback options (call again or check session). The agent receives enough information to invoke correctly and interpret outcomes.

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 wait_seconds fully (100% coverage). The description adds context by explaining what happens when the parameter expires (e.g., 2FA code, checkpoint) and advises calling again, enriching the parameter's functional meaning.

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

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

The description clearly states the tool's function: 'Launch the browser, bring the window to the front on Facebook, and wait for the user to log in by hand.' It distinguishes from siblings like check_facebook_session by specifying it watches for the session to go live rather than merely checking 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?

Provides explicit usage guidance: safe when already logged in, and if more time is needed, 'simply call it again or run check_facebook_session.' It also clarifies it 'types nothing and submits nothing,' indicating it is not for automated login, thus steering agents to use it as a waiting/reporting tool.

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

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

Goes beyond the readOnlyHint annotation by explicitly stating it will not join the group, describing behavior for private groups (returns metadata and no posts) and clarifying that this is reported explicitly rather than as an error. This adds valuable behavioral context not in the annotations.

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 three sentences, front-loaded with the primary action, and every sentence adds meaningful information (behavior, return data, edge cases). No wasted 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?

With no output schema, the description adequately explains the return value (group metadata plus posts with URL, author, text, timestamp). It also covers an important edge case (private groups). It does not detail every metadata field, but the coverage is sufficient given the schema describes parameters and the description handles the key behavioral context.

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

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

Schema description coverage is 100% with each parameter having a detailed description. The main description adds little beyond the schema, only mentioning 'newest first by default' which aligns with the sort parameter's default. This meets the baseline for high schema coverage but does not add substantial extra value.

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 action ('open a group and read its visible posts'), the resource (Facebook group), and the scope (visible posts, newest first). It distinguishes from sibling tools like search_groups or open_page by focusing on reading posts from a known group and explicitly describing the return data.

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

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

The description provides clear context: use this to open a group and read posts, noting the default sort order and private-group behavior. It does not explicitly name alternatives or when-not-to-use scenarios, but the context is sufficiently clear for an agent to infer appropriate use.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false; the description reinforces this with 'Read-only — it will not follow or like the Page' and adds what the tool returns (Page metadata plus posts). This goes beyond the annotations without contradicting them.

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 concise sentences with no filler. The main action and read-only nature are front-loaded, and every clause adds meaningful 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 read-only tool with strong annotations and full schema coverage, the description sufficiently covers purpose and return type. It does not describe response structure or pagination, but with no output schema and given the scope, it is adequately 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?

All 4 parameters have schema descriptions (100% coverage), so the baseline is 3. The tool description does not add parameter-specific context beyond the schema, which already explains limit, expand_text, and scroll_rounds.

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 verb (open), resource (Facebook Page), and expected outcome (read visible posts, return metadata plus posts). The read-only clarification distinguishes it from sibling tools that interact (follow, like, comment, post).

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

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

The description implies usage for reading a page's posts without providing explicit when-to-use guidance or naming alternatives. The read-only statement indirectly suggests it over interaction tools, but does not say when to choose open_page over search_pages, browse_feed, or read_post.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description echoes 'Read-only.' The description adds useful detail about expanded text and engagement counts, but these are return-content details rather than additional behavioral caveats. No contradiction exists.

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

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

The description is a single, front-loaded sentence that states purpose, return content, and read-only nature with no filler. Every part 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?

Even without an output schema, the description lists the expected return fields (author, text, timestamp, engagement counts, attribution, external link), making expectations clear for a simple read-only tool. It lacks error-case or URL-format caveats but remains adequate for the tool's low complexity.

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

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

Schema coverage is 100% for the single parameter post_url, which is described as 'Permalink to the post.' The description repeats 'by URL' but adds no new format, validation, or usage details beyond the schema. Baseline 3 applies where schema carries the semantic weight.

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?

Description clearly states the tool's function: 'Open a single post by URL and return its full content' and enumerates specific return fields (author, text, timestamp, engagement counts, attribution, external link). This is a specific verb+resource that distinguishes it from sibling tools like read_post by emphasizing URL-based retrieval and expanded content.

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?

Implied usage is for fetching a specific post by permalink, but the description does not explicitly state when to use this tool versus alternatives like read_post or get_post_details. No exclusions or alternative scenarios are provided, so guidance remains 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?

The description discloses key behavioral traits beyond the annotations: it does not actually post, it builds a preview, and it returns a confirmation_token. This explains the two-phase commit pattern, which is not evident from annotations alone.

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

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

Three concise sentences, front-loaded with the core purpose and then clarifying the critical non-posting behavior. Every sentence earns its place, with no redundancy or fluff.

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

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

Despite lacking an output schema, the description mentions the confirmation_token and the required follow-up (confirm_action), covering the essential output and next step. It is complete for a staged-action tool with a well-specified schema.

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?

All three parameters have detailed schema descriptions, so the baseline is 3. The description adds little beyond the schema, only reinforcing that comment_text is the exact text to be published. It does not introduce new parameter semantics.

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 'Stage a comment on a Facebook post', which is a specific verb+resource. It explicitly contrasts with actual posting by saying 'This does NOT post anything', distinguishing it from siblings like create_post and confirm_action.

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

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

It provides clear workflow guidance: 'Show the preview to the user and call confirm_action only after they explicitly approve it.' This tells the agent exactly when to use this tool and what next step to invoke, differentiating the staging action from the committing action.

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

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

The description discloses critical behavioral details beyond the annotations: it does not actually react, returns a preview and confirmation_token, and reactions are public/attributed. This adds significant context about the two-step process and social consequences, with no contradiction to the annotation flags.

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 only two sentences, front-loaded with the essential staged behavior, followed by the public/approval context. No wasted words; every clause adds 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 tool with no output schema, the description compensates by mentioning the preview and confirmation_token. It also places the tool in the broader approval flow. Minor gap: it does not explicitly link to confirm_action or explain how the token is used, but the sibling list and existing context make this inferable.

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 parameters (post_url, reaction, require_confirmation) are already documented. The description adds no new parameter-level detail beyond what the schema provides, meeting the baseline for high coverage.

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

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

The description uses a specific verb 'Stage' and explicitly states it does NOT react yet, clearly distinguishing it from an actual mutation. It also contextualizes the tool within the approval workflow by mentioning the confirmation token and the same approval step as comments, differentiating it from immediate-action tools like post_comment.

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 clearly implies this tool is for staged reactions requiring subsequent confirmation, and it notes the public/attributed nature as a caution. It does not explicitly name alternatives (e.g., confirm_action) or state when not to use it, but the context is strong enough for correct selection.

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

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

The description reveals a significant behavioral trait beyond the readOnlyHint/destructiveHint annotations: the tool attempts to reorder comments into 'All comments' and reports whether the switch succeeded. This gives the agent important context about response interpretation, which the annotations alone do not convey.

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

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

Three sentences, no fluff. The main purpose is front-loaded, the behavioral nuance is explained in one clause, and the read-only safety note reinforces the annotation without being redundant. Every sentence 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 read-only tool with 5 parameters and no output schema, the description adequately covers the key outcome (comments and the success flag for ordering switch). It could mention the structure of the returned comments, but the openWorldHint and the simplicity of the operation make this a minor gap rather than a critical 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?

All five parameters are documented in the schema (100% coverage), providing the baseline of 3. The description adds semantic depth to the 'sort_all' parameter by explaining why the ordering switch matters (knowing whether the thread is filtered) and that the result indicates success. The other parameters are self-explanatory from schema descriptions.

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

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

The description opens with a clear verb+resource pair: 'Read the comment thread on a post.' It also distinguishes from sibling tools like read_post by focusing specifically on comments and mentions the unique behavior of switching to 'All comments' ordering.

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 usage context is implied ('if you need comments, use this'), but the description does not explicitly mention alternatives or exclusion criteria. It does provide useful situational context about the 'Most relevant' vs 'All comments' ordering, but stops short of saying 'use this instead of X'.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description confirms 'Read-only' but adds no additional behavioral context such as authentication, rate limits, or response specifics. It is consistent with the annotations but contributes minimal extra value.

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, concise sentence that directly states the action and outcome. It is front-loaded with the key operation and contains no wasted 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?

For a one-parameter read tool with annotations, the description covers the core function and mentions return content. However, the explicit statement 'Identical to open_post' creates ambiguity about tool selection and fails to justify the existence of both tools, leaving the context incomplete.

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 describes post_url as 'Permalink to the post' with 100% coverage. The description merely restates 'post by URL' without adding format, validation, or usage details, so it adds no extra meaning 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 uses a specific verb 'fetch' and identifies the resource as a post by URL, stating it returns full content. However, it says 'Identical to open_post' without explaining any distinction, which slightly weakens its ability to uniquely identify the tool's purpose.

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 references 'open_post' as an identical alternative but provides no guidance on when to use this tool instead. It does not state any conditions, prerequisites, or exclusions, leaving the agent without clear selection criteria.

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

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

The read-only behavior is already declared in annotations, but the description adds useful context that results are limited to what the Facebook UI actually renders for the user's account. This gives insight into result variability 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?

The description is three short sentences, front-loaded with the primary action, and contains no filler. Every sentence provides relevant information.

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

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

The description covers the core purpose, safety, and a key limitation. There is no output schema, and the description mentions 'structured results' without specifying the structure, which is a minor gap. Overall, it is sufficient for a search tool with good annotations.

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 schema fully documents all five parameters. The description only restates the result_type behavior already present in the schema enum, adding no additional parameter-level meaning.

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 performs a Facebook search and returns structured results, with result_type explicitly selecting the tab. However, it does not distinguish this from sibling tools like search_groups or search_pages, which are more specialized.

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

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

The description implies this is the general search entry point by mentioning the different tabs, but it does not explicitly state when to use this over the specialized sibling tools. There are no exclusions or alternative recommendations.

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

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

Beyond the readOnlyHint annotation, the description explicitly states 'Read-only — it never sends a join request,' which adds specific behavioral context. It also notes that membership status is shown 'where visible,' providing useful nuance about data availability. This adds value without contradicting annotations.

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 long, front-loaded with the primary purpose and return fields, and ends with a key safety guarantee. Every sentence earns its place with zero 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?

The description covers the essential aspects: purpose, returned data, and read-only behavior. Since there is no output schema, the explicit mention of return fields is valuable. It could further mention session requirements or pagination nuances, but these are covered by the schema and sibling tooling, making it sufficiently 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?

The input schema already provides complete descriptions (100% coverage) for all four parameters, including constraints and defaults. The description does not add additional parameter-level meaning beyond what the schema offers, 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 states the tool's function: 'Find Facebook Groups matching a query.' It uses a specific verb and resource, and distinguishes from sibling tools like search_facebook and search_pages by focusing on groups and enumerating the returned fields (name, URL, privacy, member count, membership status).

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

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

The description provides clear context for when to use this tool (searching for groups) and implies a safe read-only operation, but it does not explicitly discuss alternatives or when not to use it. The sibling list shows other search tools, but the description alone doesn't draw that comparison.

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

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

Annotations already declare readOnlyHint true and destructiveHint false, so the description's 'Read-only' adds little beyond the annotation. However, it adds behavioral context by noting it uses Facebook's native in-group search and is 'much cheaper' than scrolling, which gives the agent cost/benefit awareness. No disclosure of potential limitations or return format, so additional behavior is not covered.

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 purpose in the first sentence. The second sentence provides a usage guideline and the third repeats a safety clue. No redundant content beyond the read-only note, which is harmless.

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

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

Given the schema fully documents parameters and annotations cover safety, the description provides sufficient context for a search tool: scope (inside one group), trigger (known keyword), and cost comparison. The absence of an output schema is not addressed, but the tool's name and purpose imply it returns posts; for a low-complexity search task, this 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 input schema covers all 5 parameters with descriptions (100% coverage), so the description doesn't need to explain them. The description's mention of 'keyword' aligns with the query parameter but adds no semantic value beyond the schema.

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

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

Description clearly states the tool uses Facebook's in-group search to find posts matching a query inside one group. The phrase 'inside one group' differentiates it from global search tools like search_facebook and search_groups, and the comparison to 'scrolling the whole feed' sets it apart from browse_feed.

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 context: 'Much cheaper than scrolling the whole feed when you already know the keyword' tells the agent when to use this tool (known keyword for a single group) and that it's cheaper than browsing. It does not name explicit alternative tools, but the scope and situation are 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?

Annotations already provide readOnlyHint and destructiveHint, and the description reiterates 'Read-only'. It adds the return fields, which is useful behavioral context, but does not disclose pagination behavior or rate limits. Given the annotations, this is moderate added value.

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 short sentences, front-loading the core purpose. Every word earns its place; the only redundancy ('Read-only') reinforces the annotation without bloating it.

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 4 parameters fully covered by the schema and no output schema, the description compensates by listing return fields. It is mostly complete, but lacks guidance on alternatives and edge-case behaviors, which keeps 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?

All 4 parameters have full descriptions in the schema (100% coverage), so the description does not need to explain them. The description adds no additional parameter meaning beyond what the schema already provides.

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

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

The description uses a specific verb-resource pair ('Find Facebook Pages') and lists the returned fields (name, URL, category, follower label, verification badge). It clearly distinguishes from sibling tools like search_groups by targeting Pages specifically.

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 establishes clear context: this tool is for searching Facebook Pages. However, it does not explicitly mention alternatives or state when not to use it (e.g., vs search_facebook), so it lacks explicit exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds no contradiction. It goes beyond annotations by explaining the significance of a degraded strategy and clarifying that the tool reports fallback/missed statuses, which is useful behavioral context for interpreting results.

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 long, directly states the tool's purpose in the first sentence, and adds a concise explanatory note in the second. Every word earns its place; there is no fluff or repetition.

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, zero-parameter diagnostic tool with no output schema, the description is complete: it defines what is reported, the meaning of different statuses, and the significance for users. 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 has zero parameters, so the baseline is 4. The description does not need to explain parameter semantics, and it appropriately focuses on behavioral output rather than input details.

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 what the tool does: it reports which Facebook DOM strategies have been matching, fallen back, or missed. This is a specific verb ('Report') with a clear resource ('Facebook DOM strategies') and scope (matching/fallback/missed), distinguishing it from sibling tools that perform actions like reading, posting, or searching.

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

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

The description provides clear context for when to use the tool: as an early warning for Facebook markup changes. It explains that a degraded strategy indicates extraction works but on a brittle fallback. It does not explicitly name alternative tools or state when not to use it, but the context is strong enough to guide the agent.

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 annotations already indicating readOnlyHint=false and destructiveHint=false, the description adds the key behavioral trait: no immediate share, returns a preview and confirmation_token. This enriches the agent's understanding of the tool's staged nature.

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 concise sentences immediately convey the tool's purpose and key behavior. No filler or redundant information.

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

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

The description covers the core behavior (staging, not sharing), the optional message, and the return value (preview and confirmation_token). Given the tool's simplicity and complete schema, this is sufficient, although it doesn't explain the confirmation flow in detail.

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 each parameter already has a description. The tool description provides overall context about the staging flow but does not add per-parameter semantics beyond what the schema already offers. 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 uses a specific verb 'Stage a share' and names the resource 'a post to your own timeline'. It clearly distinguishes itself from sibling tools like create_post or post_comment by emphasizing that it does NOT share yet.

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 clarifies that the tool only stages a share and does not execute it, which implies a two-step flow with confirmation. It doesn't explicitly name alternatives, but the context is clear enough for the agent to understand when to use this tool.

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