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

Annotations declare the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false), and the description adds genuinely new behavior: the write is validated, backed up, and atomic, and cookie values are never passed through the tool call. It still omits the failure mode on a duplicate account_id, which matters given idempotentHint=false.

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

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

Front-loads the destination file and the validated/backed-up/atomic guarantees in the first clause, then handles the two tricky parameters. Dense but every sentence carries information; no filler.

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

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

Return values are covered by the output schema, and the description supplies the mutation semantics and the cookie-handling security model. Remaining gaps are the duplicate-account behavior and the unexplained target_keywords semantics.

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

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

Schema description coverage is 0%, so the description carries the full burden for 6 parameters and only documents two (cookie_file, persona). It does cover the non-obvious ones well — cookie_file is clarified as an on-machine path that gets validated and copied to <account_id>_cookies.json, and persona has a 4000-char cap — but account_id, proxy, is_active, and especially target_keywords receive no explanation anywhere.

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

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

States a specific verb+resource: 'Add an account to config/accounts.json', naming the concrete persisted artifact. It does not differentiate itself from the nearby update_account / set_account_active siblings, so an agent must infer that this is the create path rather than modify.

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

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

There is no when-to-use guidance: no statement about prerequisites, what happens if the account_id already exists, or when to prefer this over update_account. The verb 'Add' implies creation, but nothing tells the agent when this tool is the right choice versus its siblings.

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 supply the safety profile (non-read-only, idempotent, non-destructive), and the description adds real behavioral detail beyond them: batch atomicity ('whole batch fails if any id belongs to another account'), dedup behavior for repeated ids, and the caveat that adding a lead does not re-qualify opted-out or closed leads. It stops short of describing permissions or partial-success reporting.

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

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

Four short, front-loaded sentences with no filler; the batch size constraint leads and each subsequent sentence adds a distinct behavioral rule.

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 an output schema present, return values need not be explained, and the description covers the key semantic edges (batch size, atomic failure, dedup, eligibility). Missing only auth/permission expectations and any campaign-state side effects, which are minor for this scope.

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

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

Schema description coverage is 0%, so the description carries the burden and only partially compensates: it bounds lead_ids to 1-100 and ties ids to 'this account', but says nothing about the account or campaign_id parameters beyond incidental mention.

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

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

States a specific verb and resource: adding 1-100 local leads from an account to a campaign. The batch bound and 'local leads' scope make the operation concrete, though it never names or distinguishes itself from close siblings like upsert_lead or list_leads.

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

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

Usage is implied by the batch/atomicity constraints, but there is no explicit guidance on when to use this versus upsert_lead or update_lead_status, and no prerequisites or preconditions (e.g., campaign must exist/is active) are stated.

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

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

The description adds significant behavioral context beyond annotations: 'Validated, deduped, backed up, atomic. Credentials are masked in the response.' This complements the idempotentHint and destructiveHint annotations effectively.

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: main action first, then key behavioral traits, then usage guidance. 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?

Covers creation, validation, idempotency, credential masking, and post-usage. Lacks error handling or edge cases (e.g., duplicate pool name), but output schema likely fills gaps. Good for a focused creation tool.

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

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

Schema coverage is 0% so description must compensate. It identifies the two parameters ('proxy URL' and 'pool') but lacks detailed format or constraints. Validation is mentioned but not specified. Adequate but not thorough.

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 the verb 'Add a proxy URL to a named pool' and specifies the target resource ('settings.json'). It clearly distinguishes from sibling tools like 'remove_proxy' and 'test_proxy' by focusing on addition.

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 guidance on how to assign the added proxy to accounts via 'update_account(proxy="pool:<name>")'. Implicitly contrasts with removal/testing tools, but lacks explicit when-not-to-use alternatives.

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

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

Annotations already declare destructive=true, idempotent=false, and openWorld=true. The description adds real value beyond them: the execution path mirrors direct mode with pacing, dedup, and metrics, and consumed/unknown ids raise an error rather than silently no-op. This is meaningful behavioral context, though it doesn't cover auth requirements or downstream side effects like what gets destroyed.

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

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

Three tight sentences, front-loaded with the core action. Every clause carries distinct information (execution semantics, idempotency/error behavior) with no redundancy or filler.

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

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

For a one-parameter mutation tool with an output schema and full annotation coverage, the description supplies what the structured fields cannot: execution-path parity and one-shot semantics. An agent has enough to invoke it correctly without additional 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 0% for the single draft_id parameter, so the description must carry the meaning. It loosely implies the id references a draft created by a write tool and that consumed ids error, but never says where to obtain a valid draft_id (e.g., list_drafts). Baseline 3 given one schema-documented param name but no added format or sourcing guidance.

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

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

States a specific verb and resource: it executes/approves a pending draft, and clarifies the draft originates from a write tool. An agent can distinguish it from list_drafts, get_draft, and reject_draft by name alone. It stops short of explicitly naming the sibling it is not (reject_draft), so it falls just short of a 5.

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

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

Gives clear triggering context (a pending draft produced by a write tool) and the precondition that approval is a one-shot operation. It does not explicitly state when to prefer reject_draft or how to recover from the 'consumed id' error, so no exclusions/alternatives are spelled out.

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 (readOnlyHint=false, idempotentHint=false) already flag this as a non-idempotent mutation. The description adds genuine context beyond them by disclosing that the call only *prepares a draft* and must be completed via approve_draft, i.e. the action is not immediate. It doesn't cover failure or duplicate-draft behavior, keeping it below 5.

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

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

Two short, front-loaded sentences with zero filler; the purpose leads and the approval constraint follows immediately. Every clause earns its place.

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

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

With an output schema present, return values needn't be described, and the approval requirement is stated. Still, for a mutation tool with 0% parameter coverage, the description omits what the draft/queue lifecycle does and what 'account' selects, leaving meaningful 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 description coverage is 0% for both required parameters, so the description must compensate. 'One exact post' loosely implies tweet_url takes a single post reference, but 'account' is never explained and no format or constraint guidance is added.

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

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

States a specific verb+resource ('Prepare a bookmark draft') and narrows scope to 'one exact post', which lets an agent distinguish it from get_bookmarks and remove_bookmark. It stops short of naming a sibling, so it's clear but not fully differentiated.

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?

'Always requires approve_draft' conveys the mandatory follow-up step in the draft/approval workflow, which is real usage context. However, it gives no when-not guidance or explicit alternative routing for the sibling bookmark tools.

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 provide readOnlyHint false, destructiveHint false, idempotentHint true. The description adds behavioral context by specifying state transition constraints, which goes beyond annotations. No contradiction.

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 extremely concise: two sentences, no fluff, front-loaded with the main purpose followed by constraints.

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

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

The description adequately covers the tool's purpose and constraints. It does not explain response or prerequisites, but given the output schema exists and the tool is simple, it is fairly 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?

With schema description coverage at 0%, the description must compensate but does not mention the queue_id parameter. The parameter name is self-explanatory, but no additional semantics are provided.

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 'Cancel' and the resource 'queued action', and specifies the allowed states (pending or failed). It does not explicitly differentiate from siblings like reject_draft, but the state constraints provide implicit distinction.

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 conditions for use (only pending or failed items) and what cannot be cancelled, but it lacks explicit guidance on when to use this tool versus alternatives among siblings.

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

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

Goes well beyond the annotations, which only declare readOnly=false, destructive=false, idempotent=true. The description clarifies that despite the 'cancel' verb nothing is destroyed ('never deletes posts'), specifies exactly what survives (confirmed URLs, uncertain evidence), and adds a hard precondition on active sends. This is precisely the non-obvious behavioral context an agent needs.

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

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

Three short sentences, front-loaded with the core action and then layering retention guarantees and the precondition. Little waste, though the final precondition sentence reads slightly awkwardly ('before cancellation can be accepted').

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 an output schema present, return values need no explanation, and the annotations carry the safety profile; the description fills the remaining gap with retention semantics and preconditions. Adequate for a single-parameter mutation, though the run_id parameter remains entirely undocumented.

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

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

Schema description coverage is 0% and the single run_id parameter is never mentioned in the description, so it adds no meaning for the parameter. However, run_id is a conventional identifier and its role is reasonably inferable from the 'thread' context, keeping this near the minimum-viable baseline.

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

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

States a specific verb and resource: 'Cancel remaining thread segments locally.' This clearly distinguishes it from continue_thread and prepare_thread. It stops short of naming a sibling explicitly, but the action and scope are unambiguous.

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

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

Provides a precondition ('An active send must finish before cancellation can be accepted'), which is useful usage context, but never states when to prefer this over alternatives like cancel_queued_action or simply letting a run complete. Usage is implied rather than directed.

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 idempotentHint=true, destructiveHint=false, and openWorldHint=false, covering the safety profile. The description adds one genuinely useful behavioral detail—that the operator's cookie file is retained—implying login state persists. It does not clarify auth requirements or what exactly is torn down.

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 zero waste; the operation and its key side effect are stated immediately.

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?

An output schema exists, so return values need not be explained, and annotations carry the safety profile. The description is nearly sufficient, missing only account identifier format and any prerequisite/authorization 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?

With a single parameter at 0% schema coverage, the description must compensate; it only implies the 'account' selects which browser context to close. It does not specify the expected identifier format (id vs handle), leaving a gap.

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

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

Specific verb+resource: 'Close one account's browser context' clearly states what the tool does and scopes it to a single account. It does not explicitly differentiate from related siblings like get_session_status, so it stops short of a 5.

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

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

No guidance on when to use this tool versus alternatives such as get_session_status, and no prerequisites or conditions are given. The agent must infer usage context entirely.

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 mark this as a non-readonly, non-idempotent write, and the description adds real behavioral value beyond them: it will not resend uncertain segments, addressing the duplicate-send risk implied by idempotentHint=false. It still omits auth/preconditions for a resume operation.

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

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

Two tight sentences with the resume condition front-loaded and the safety caveat last. Dense jargon ('spacing/budget/preflight') is unexplained, but no filler.

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

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

An output schema exists so return values need no explanation, and annotations cover the safety profile. However, the description never defines what an 'approved run' is or how it relates to approve_draft/get_run_status, leaving an agent to infer the workflow.

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

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

Schema coverage is 0% so the description must carry parameter meaning, but it never mentions run_id or its expected form. The single parameter is a conventional identifier, so the loss is limited, but nothing compensates for the coverage gap.

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

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

States a specific verb (resume) and resource (an approved run), and clarifies the exact resume point ('known unsubmitted segment'). It implicitly separates itself from get_thread_run and cancel_thread by scope, though it never names a sibling explicitly.

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

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

Gives a clear usage condition — resume only 'after spacing/budget/preflight recovery' and only at a known unsubmitted segment. It lacks an explicit when-not or a named alternative, but the trigger context is spelled out.

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 annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=false, so the safety profile is covered structurally. The description adds genuinely useful context the annotations don't carry: writes are local-only, nothing is dispatched, and notes cannot be templated. It does not mention permissions, dedup behavior, or how repeatedly calling it behaves.

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?

Purpose is front-loaded in the first clause and the four sentences are compact with little filler. Fragments like "Notes cannot be templated" are terse but still earn their place as a real constraint.

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?

An output schema exists, so return-value explanation is rightly omitted. For a three-required-parameter mutation with no schema descriptions, though, the definition leaves the 'account' and 'name' inputs and any permission/idempotency implications undefined, which is a meaningful gap for an agent to call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate, and it does explain message_template in depth (accepted tokens, the placeholder requirement, the {name} -> @handle fallback). But 'account' and 'name' are left completely unexplained, so the compensation is only partial.

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?

"Create a local draft campaign" gives a specific verb and resource, and the trailing "Nothing sends" makes the scope unambiguous (a draft, not a send). It is distinguishable from send_message and prepare_campaign_messages, but it never explicitly names or routes to a sibling, so it stops short of a 5.

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

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

The phrase "local draft" and "Nothing sends" imply this is the non-dispatching entry point, so usage is inferable. However there is no explicit when-to-use statement or comparison against related tools like prepare_campaign_messages, add_campaign_leads, or set_campaign_status.

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 are thin (destructiveHint=false, idempotentHint=false) and could mislead, but the description supplies the missing behavior: deletion is permanent, cannot be undone, and is only staged here pending approve_draft. It also discloses the exact-match guard ("supply its current text") and the media-only empty-string convention.

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

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

Three short sentences, zero filler, with the destructive nature and the approval requirement front-loaded where an agent will read them before acting.

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?

An output schema exists, so return values need not be explained, and the description covers the destructive action, its reversibility, and its approval gate. It is only slightly thin on the parameters with no schema documentation and on what happens when expected_text does not match.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning; it explains expected_text well (current text, empty for media-only) but says nothing about account or tweet_url. Those names are largely self-evident, so it partially compensates but not fully.

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?

"Prepare permanent deletion of your own exact post" gives a specific verb (prepare deletion), a precise resource (your own post), and a scope qualifier (exact / own) that separates it from siblings like edit_tweet or unlike_tweet. An agent can identify it without opening the schema.

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

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

"Always requires approve_draft" names the gating sibling and the prerequisite condition for completion, and "your own" excludes posts the account does not own. It does not explicitly contrast with edit_tweet or remove_bookmark, so it falls short of full when/when-not guidance.

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

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

Beyond annotations (readOnlyHint=false, destructiveHint=false), description clarifies that the tool creates drafts but does not post, and mentions persona-aware server-side LLM. 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?

Two concise sentences: first explains the main action, second clarifies behavioral constraints and requirements. No unnecessary words, and critical information is front-loaded.

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?

Output schema exists, but description does not explain the return value. Additionally, it lacks explanation for the 'account' parameter. Given moderate complexity, more context on parameter usage would improve completeness.

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

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

With 0% schema description coverage, the description should explain all parameters. It mentions 'count' and 'topic' but does not explain 'account', which is a required parameter. This leaves ambiguity about which account is used.

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 action: generate distinct takes on a topic using server-side LLM and stage as drafts. It specifies the verb (generate), resource (post drafts), and scope (count distinct takes). This distinguishes it from siblings like 'prepare_reply' and 'generate_and_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?

Description explains that nothing is posted and one can approve or reject drafts, and it lists the prerequisite (LLM block in settings). However, it doesn't explicitly state when not to use or compare to alternative tools for similar tasks.

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

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

Beyond the annotations (readOnly=false, destructive=false, idempotent=false) the description adds substantive behavior: approval is always required, edit-post must be exposed by X, eligibility/time limits apply, and media replacement is unsupported. These are exactly the operational facts an agent needs and that the annotation set does not encode.

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

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

Front-loaded with the core purpose, then constraints, in four tight sentences with little waste. The stray 'configure self_handles' clause is the one line that does not earn its place and slightly muddies an otherwise efficient 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?

An output schema exists, so return values need not be described, and annotations cover the safety profile. However, for a four-parameter mutation tool with zero schema description coverage, the description leaves account and tweet_url undocumented and references a phantom parameter, so it is not fully complete for correct invocation.

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

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

Schema description coverage is 0%, so the description carries the full burden. It only loosely maps 'current exact text' and 'replacement' to expected_text and text, leaves account and tweet_url unexplained, and introduces a non-existent 'self_handles' parameter that matches nothing in the schema, creating confusion rather than clarity.

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

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

States a specific verb and resource: 'Prepare a text edit of your own post.' This distinguishes it cleanly from siblings like delete_tweet, post_tweet, queue_post, and reply_to_tweet, and the 'prepare' framing signals it stages an action rather than committing one.

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 real preconditions: 'X must expose Edit post; eligibility/time limits apply' and 'Always requires approval.' That tells the agent when the tool is usable, but it never names alternative siblings (e.g. delete_tweet or a repost path) for when editing is not eligible, so it stops short of explicit when-not guidance.

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

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

Annotations indicate mutation (readOnlyHint=false) and non-destructiveness. The description adds that every candidate passes a relevance gate, max_actions is capped per account, and draft mode prevents execution. These details go beyond annotations, though the direct execution mode is only implied.

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, about 60 words, front-loaded with purpose. Every sentence adds essential information without fluff. Well-structured for quick comprehension.

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 has an output schema (not shown) and siblings, the description covers core behavior: actions, draft mode, caps. It does not explain return values or error handling, but these are inferred from the schema. Overall adequate for standard usage.

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

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

Schema coverage is 0%, but the description clarifies that actions is a subset of ['like', 'retweet'] with default ['like'] and that max_actions is hard-capped. However, keywords and account are not explained, and the schema lacks enums. The description adds moderate value beyond the bare 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 clearly states the tool engages with tweets from keyword search using actions like or retweet. It specifies the verb 'engage' and the resource 'tweets found via keyword search', but does not explicitly differentiate from siblings like queue_engagement or reply_to_tweet.

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 mentions draft mode by default and hard-capped max_actions, implying when to use (mass engagement with approval). However, it does not explicitly state when not to use or provide alternatives, leaving some reliance on inference.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and non-idempotent, so the safety profile is covered. The description adds the non-obvious fact that this only stages a draft and that approve_draft commits it, which is real behavioral value beyond the annotations. It does not mention that repeat calls create additional drafts or what authorization the account needs.

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

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

A single sentence with zero filler, front-loading the action and appending the hand-off to approve_draft. 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?

An output schema exists, so return values need not be described, and the two-phase draft/approve model is disclosed. The remaining gap is parameter ambiguity between 'account' and 'profile', which is left entirely to the 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?

Schema description coverage is 0% and both required parameters ('account', 'profile') are bare strings with no titles beyond their names. The description clarifies that 'profile' is the target X profile but says nothing about what 'account' means (which credential/identity acts) or their expected format (handle vs ID). It fails to compensate for the coverage gap.

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?

Uses a specific verb+resource pair ('prepare a follow draft') scoped to 'one X profile', and explicitly states that approve_draft performs the actual action, which cleanly separates it from that sibling. An agent can distinguish it from approve_draft, unfollow_profile, and reply_to_tweet without opening a schema.

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

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

Gives the operative context: this is the preparatory step and approve_draft is the commit step, which tells the agent where this fits in the workflow. It stops short of naming when not to use it (e.g., versus unfollow_profile or a direct follow path), so it is clear context without 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?

The description adds significant behavioral context beyond annotations by explaining the draft mechanism: the generated text is stored in a draft's payload/preview for human review before posting. However, it does not disclose whether a non-draft mode exists or other side effects like rate limits or authentication needs.

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 concise with two sentences. The first sentence clearly states the core functionality, and the second adds the critical draft mode detail. No unnecessary 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?

While an output schema exists (reducing the need to explain return values), the description omits important lifecycle context: it does not mention that the tool creates a draft that requires manual approval via sibling tools like 'approve_draft'. The name 'generate_and_post' is misleading as the default behavior is to only draft.

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 description explains the 'topic' parameter by name and context, but does not explain the 'account' parameter. With 0% schema description coverage, the description adds partial value but falls short of fully compensating for the gap.

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 generates a post on a given topic using an LLM and then posts it, with a default draft mode. This distinguishes it from sibling tools like 'post_tweet' (post without generation) and 'draft_post_variations' (generate drafts without posting).

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 explains the default draft mode but does not explicitly state when to use this tool vs. alternatives such as 'post_tweet' or 'draft_post_variations'. There is no guidance on when not to use it or what the non-draft mode (if any) entails.

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?

Description adds context beyond annotations: specifies that cookies, password, and proxy credentials are masked, and that no browser is started. Aligns with readOnlyHint=true.

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

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

Two sentences, no fluff, effectively communicates core behavior and constraints.

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 getter with an output schema and clear annotations, the description adequately covers behavioral traits, output content, and safety. No missing information for its scope.

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

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

The single 'account' parameter lacks schema description and the tool description does not specify its format or expected values. With 0% schema description coverage, the description should compensate but does not.

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?

Clearly states it shows one account's masked config and cookie-file status. Distinguishes from siblings like list_accounts and get_account_health.

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?

Indicates it is read-only and never starts a browser, conveying safe usage context. However, it does not explicitly contrast with sibling tools or provide when-not-to-use scenarios.

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/openWorldHint annotations, the description discloses a real auth requirement (X Premium) and a failure mode (unsupported layouts return no metrics, i.e. empty results). It does not cover rate limits or pagination, but the added behavioral context is meaningful.

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

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

Three tight sentences with no filler, and the core scoping statement is front-loaded. The jargon ("observed paywall") is slightly opaque but costs little.

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?

An output schema exists so return values need not be described, and the auth/layout caveats are covered. The gap is parameter meaning: with 0% schema coverage and one required param of unclear semantics, the definition is not complete enough for confident invocation.

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

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

Schema description coverage is 0% for two parameters, and the description never explains what "account" refers to (the owner handle? a target?) or what "limit" bounds. With the schema contributing nothing, the description needed to compensate and does not.

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?

It gives a specific verb and resource ("Read ... X analytics availability"), but "availability" is genuinely ambiguous: it is unclear whether the tool returns metrics or a boolean about whether analytics are available, especially since the same sentence references "no metrics" and "local action metrics." It does differentiate from siblings ("Distinct from local action metrics and public post counts"), which lifts it above a vague 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?

It gives one conditional prerequisite ("Requires X Premium when the observed paywall says so") and names contrasting sibling outputs, implying when this tool is appropriate. However, it never states an explicit when-to-use trigger or tells the agent which sibling to call instead of this one.

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 only declare readOnlyHint=true and openWorldHint=false, so the description adds meaningful behavioral context beyond them: it never starts a browser, a config failing validation is REPORTED rather than raised, unknown evidence earns no points, and it does not predict X enforcement or establish live authentication. These are important traits for an agent interpreting the result.

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 definition front-loads the snapshot contents and then qualifies semantics efficiently. It is somewhat dense (two long sentences plus a fragment about config validation), but every clause adds information and 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?

An output schema exists, so return-value structure is covered elsewhere, and the description appropriately focuses on interpretation caveats. However, with 0% schema coverage on the only parameter, it leaves identifier format unaddressed, and offers no usage routing among the many account-related siblings.

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

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

Schema description coverage is 0% for the single account parameter, so the description must carry the load. It implies the account is the subject of the health check but adds no detail on identifier format (handle vs. ID vs. email). Baseline for the low-coverage single-param case is 3; the description does not fully compensate.

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 enumerates exactly what the snapshot contains (config presence, cookie-file validity, metrics counters, warm-session state, queue depth, pending drafts, readiness score) and states the verb (read-only health snapshot for one account). This clearly distinguishes it from siblings like get_runtime_info, get_account_safety, and get_account_analytics.

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?

No explicit when-to-use or when-not-to-use guidance. The description contrasts with X enforcement prediction and live authentication, but never says when an agent should call this versus get_account_safety, get_session_status, or get_runtime_info. There is implied context (diagnosing account readiness) but no routing guidance.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safe-read profile is covered. The description adds only that it surfaces pending writes needing reconciliation, a minor operational hint; it says nothing about auth requirements, scope, or failure behavior beyond what annotations and the output schema 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?

A single front-loaded sentence with no filler; the verb and the returned data lead. It is arguably too terse, using unexplained jargon instead of a short clarifying clause, which marginally undercuts the efficiency.

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 diagnostic read tool sitting in a dense family of account tools (get_account_health, get_account, pause_account_actions, resolve_action_outcome), the description does not explain the meaning of 'local limits', the relationship to those siblings, or the account identifier. The output schema covers return structure, but the missing routing and term-definition context leave the definition 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?

Schema description coverage is 0% and the sole parameter 'account' is never mentioned in the description, so its expected format (ID, handle, or name) is undocumented everywhere. With low coverage the description should compensate, and it does not.

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

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

States a clear verb ('Read') and enumerates the three specific things returned: local limits, pause reason, and writes needing outcome reconciliation. It is more specific than a tautology, but it never distinguishes itself from the close sibling get_account_health, nor defines what 'local limits' or 'account safety' actually mean.

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

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

There is no statement of when to call this versus get_account_health, list_accounts, or get_account. The mention of 'pause reason' and 'writes needing outcome reconciliation' hints at a diagnostic role before pause/resume or resolve_action_outcome workflows, but the agent must infer this entirely.

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 establish readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds real behavioral value beyond that: it discloses that results are only 'partial' and that bookmark folders are not traversed, which tells the agent not to rely on this for complete bookmark retrieval.

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

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

Two tight sentences, front-loaded with the core action and immediately qualified by the partial-results and folder-scope caveats. Zero waste.

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

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

An output schema exists so return values need not be explained, and annotations carry the safety profile. However, with two undocumented parameters and no explicit usage routing, the description leaves gaps an agent would need to resolve elsewhere.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does not. 'Bounded' loosely gestures at the limit parameter, but the required 'account' parameter and the meaning/default of 'limit' are never explained in the description.

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

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

States a specific verb (read) and resource (default bookmarks feed) with scope qualifiers ('bounded', 'default feed'). The note that 'bookmark folders are not traversed' helps distinguish it from a full bookmark traversal, though it does not name the specific siblings (bookmark_tweet, remove_bookmark) it relates to.

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

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

Usage is implied through scope ('default bookmarks feed') but there is no explicit guidance on when to call this versus alternatives like get_home_feed or search_tweets, and no conditions or exclusions are stated. The agent must infer the 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 declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds a pagination hint plus the limit range '1-100', which is genuinely useful behavioral context. However, it references 'members_next_offset', a field that appears nowhere in the input schema, which muddies rather than clarifies the pagination contract for the consumer.

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?

It is short and starts with the verb 'Read', which is good. But the two clauses are run together into a single garbled sentence whose second half ('membership page ... local outcomes') costs more comprehension than it buys.

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?

An output schema exists, so return-value documentation is not required. Still, for a 4-parameter tool with 0% schema coverage and two required identifiers, the description omits the meaning of the required parameters and mentions an output-looking field ('members_next_offset') that isn't in the schema, so an agent lacks what it needs to call this correctly.

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

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

Schema description coverage is 0%, so the description carries the full burden and only partially discharges it. It documents limit's range (1-100) and implies offset via 'next page', but account and campaign_id — both required — get no explanation at all. The reference to a non-existent 'members_next_offset' further confuses the pagination 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 does give a verb+resource ('Read this account's campaign'), which is enough to place it near siblings like get_campaign_summary and list_campaigns. But the second half ('a membership page') is unexplained and doesn't map onto any visible concept in the tool, leaving the actual scope fuzzy. It neither distinguishes itself from siblings nor states cleanly what object is returned.

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

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

There is no indication of when to use get_campaign versus get_campaign_summary, list_campaigns, or create_campaign. No prerequisites are stated (e.g. that campaign_id must come from list_campaigns). The agent is left to infer usage entirely from the name.

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 it read-only and closed-world, and the description adds useful context: the data is local/recorded, it does not check X, and it does not send work. This goes beyond the annotations, though it does not cover auth, rate limits, or other operational details.

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-loaded with the core operation and followed by an important behavioral boundary. Every sentence adds relevant information without waste.

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

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

Output schema and annotations are present, so return values and safety profile need not be explained. However, with two required parameters and no parameter semantics in either the schema or description, the definition is incomplete for invocation guidance.

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

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

Schema description coverage is 0%, and the description does not explain either required parameter. It does not clarify what 'account' represents or what format 'campaign_id' should take, leaving parameter meaning entirely to the bare schema titles.

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

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

The description states a specific verb and resource: 'Read local membership/delivery counts and opt-out suppression count.' It clearly distinguishes the recorded-outcome nature from tools that check X or send work, though it does not name a specific sibling alternative.

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 a when-not boundary by saying it never checks X or sends work, which implies use for local recorded outcomes. However, it does not explicitly say when to choose this over siblings like get_campaign, list_campaigns, or get_metrics.

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 openWorldHint, but the description adds genuinely useful behavior: the cursor is bounded to the visible window, and opening the conversation may clear unread state. That unread-clearing side effect is real value the annotations don't convey, though return format and pagination behavior remain unstated.

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

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

Three short sentences with little waste and the read purpose front-loaded, but the phrasing 'observed request/reply state' and 'does not accept requests' is terse to the point of ambiguity rather than dense with meaning.

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?

An output schema exists so return values needn't be described, and annotations cover the safety profile. However, for a 4-parameter tool with 0% schema coverage, the description leaves parameters and selection context unexplained, so it is only 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?

Schema description coverage is 0% across all four parameters. The description's mention of a 'cursor' loosely gestures at before_message_id, but account, conversation_id, and limit are never explained, and the cursor/window relationship is not clarified beyond what the schema already shows.

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

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

The description names a specific verb (Read) and resource (conversation context), but the scope-noun 'observed request/reply state' is opaque and the tool is not distinguished from close siblings like get_thread, get_inbox, or search_conversations. An agent can roughly tell it reads a conversation but not how it differs from those alternatives.

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?

No when-to-use guidance and no named alternative. The line 'Does not accept requests' hints at scope but is not a selection criterion, and nothing tells the agent when get_conversation should be preferred over get_thread or search_conversations.

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 states 'Opening may mark read,' which is a state mutation, directly conflicting with the readOnlyHint=true annotation asserting the tool does not modify its environment. Although it also discloses genuinely useful behavior (unsupported layouts return an error rather than guessed capabilities), the presence of an annotation contradiction forces a 1.

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

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

Two tight sentences, front-loaded with the purpose and followed by the caveats, with no filler. Efficiency is good; only the density of undefined jargon keeps it from a 5.

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

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

An output schema exists, so return values need not be described, and the description does add behavioral caveats (error on unsupported layouts, possible mark-read). But with both required parameters wholly unexplained, the definition is not complete enough for confident invocation. Minimum viable.

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

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

Schema description coverage is 0% and there are two required parameters (account, conversation_id) that the description never explains. The only hint is the phrase 'conversation-menu', which loosely maps to conversation_id but leaves 'account' and the identifier formats entirely undocumented. The description does not compensate for the coverage gap.

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 pairs a verb ('Inspect') with a resource ('visible request and conversation-menu controls'), giving a workable if jargon-heavy sense of what it does. However, it offers no differentiation from close siblings such as get_conversation or manage_conversation, so an agent cannot easily tell which one to reach for. Adequate but with clear gaps.

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

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

There is no explicit when-to-use guidance, no named alternative, and no prerequisites or preconditions stated. The reader is left to infer the tool's role in the conversation flow entirely from the name. Only mildly implied usage, so a 2.

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 repeats the annotation's readOnlyHint as 'Read-only', which is redundant. No additional behavioral traits (e.g., error conditions, rate limiting, or side effects) are disclosed. The annotation already covers safety, so the description adds no 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 extremely concise with two short sentences. No unnecessary words, and it front-loads the core purpose. Perfectly sized for a simple retrieval tool.

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 (1 required param, read-only, with output schema), the description adequately covers the basics. It could mention that the draft_id must exist, but the output schema likely provides return field details.

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 0% description coverage for its single parameter (draft_id), and the tool description does not provide any additional meaning, constraints, format, or examples. The description fails to compensate for the schema gap.

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 'Show', the resource 'draft', and the identification method 'by id'. This effectively distinguishes it from sibling tools like list_drafts (list all) and approve_draft (modify).

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 when you have a specific draft id, but it does not explicitly state when to choose this tool over alternatives like list_drafts, approve_draft, or reject_draft, nor does it mention any prerequisites or prohibitions.

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 openWorldHint=true, so the safe-read profile is covered structurally. The description adds the useful constraint that no engagement actions are performed, which prevents the agent from expecting post/like/retweet behavior. It does not add pagination or ordering 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 efficient sentence with the core action front-loaded and no filler. It is very terse, but nothing is wasted.

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

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

An output schema exists, so return values needn't be explained. However, with 0% schema description coverage on two params and no usage routing, the description is only minimally adequate for a tool whose 'account' parameter carries the real invocation risk.

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

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

Schema coverage is 0% – neither 'limit' nor 'account' is documented in the schema or the description. The description gives no meaning for 'account' (which account context?) or the default limit of 20, leaving both parameters to be inferred.

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

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

States a specific verb ('Read') and resource ('posts currently visible in the home feed'), so it's clear what the tool returns. It distinguishes itself lightly from engagement tools via 'no engagement actions', but does not name a specific sibling to route the agent.

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?

'no engagement actions' implies the tool is read-oriented and hints the agent should reach for engagement tools elsewhere, but there is no explicit when-to-use context or named alternative among the many sibling read tools (get_profile_posts, search_tweets, get_notifications). Usage is only implied.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds real value beyond that: it discloses a side-effect boundary ('never opens or accepts a conversation') and a verification behavior for Native Unread selection, telling the agent this read does not advance conversation state.

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

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

Two sentences, no filler, and the core read scope is front-loaded. The second sentence is somewhat cryptic ('Native Unread selection is verified when available') but it is not padding.

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

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

An output schema exists, so return values need no explanation, and the safety profile is annotation-covered. However, for a five-parameter tool with zero schema coverage, the description omits pagination/limit behavior and the account parameter, leaving the definition thin for correct invocation.

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

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

Schema description coverage is 0%, so the description carries the full parameter burden, and it only partially delivers. It enumerates the folder values and the all/unread/read filter values, but says nothing about limit, account, or the semantics of unread_first, leaving three of five parameters unexplained anywhere.

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

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

The description states a specific verb and resource: reading visible inbox/requests/other summaries, with the filtering dimension named. It implicitly distinguishes itself from conversational reads via 'never opens or accepts a conversation,' but never names a sibling tool to route against. Clear but not fully differentiated.

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

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

Usage is only implied: the agent can infer this is the listing tool for inbox-type folders. The phrase 'never opens or accepts a conversation' establishes a boundary, but there is no explicit guidance on when to pick this over get_conversation, search_conversations, or get_notifications.

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 establish readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds that the lead is 'local' (account-scoped, not open-world) and that notes are included, but discloses nothing about error behavior, permissions, or how a missing lead is handled.

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 zero filler; the resource and scope come first and 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?

An output schema exists and annotations cover the safety profile, so the description does not need to enumerate return values - and it still flags that notes are included. Adequate for a two-param read, though param formats remain unspecified.

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

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

Schema description coverage is 0%, so the description must carry the burden, yet it only alludes to the two params ('this account', 'one lead') without any format or identification guidance (e.g., what a lead_id looks like). It adds marginal meaning over the schema titles.

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

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

States a specific verb (Read) and resource (one local lead) with a scope qualifier ('belonging to this account'), and 'one' implicitly contrasts with the sibling list_leads. It stops short of explicitly naming a sibling, so it is clear but not fully differentiated.

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 singular 'one local lead' implies single-record retrieval versus the sibling list_leads, but there is no explicit when-to-use, prerequisite, or alternative named. Usage must be inferred.

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=true. Description adds valuable context 'never starts a browser', which is beyond annotations. No contradictions.

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, front-loaded with purpose. Every sentence adds value without 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?

Given the presence of an output schema and a single simple parameter, the description covers the main points: what data is returned and that it's read-only. Could be enhanced by specifying account identifier format.

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 has one parameter 'account' with 0% description coverage. Description mentions 'for an account' but does not specify expected format or how to identify the account. Fails to compensate for lack of schema documentation.

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 verb 'Read', the resource 'recorded metrics for an account', and specifics 'counters + recent events'. Distinguishes from siblings like get_account_health by focusing on metrics.

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?

Implies safe usage with 'Read-only, never starts a browser', but does not explicitly state when to use vs alternatives like get_account_health or list_accounts. Lacks explicit guidance.

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

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

The description adds real behavioral context beyond the annotations: 'Visiting this view may mark X notifications read', 'absent evidence remains unknown', and 'visible supported UI' scope. However, that first disclosure conflicts with the declared readOnlyHint=true, which asserts the tool does not modify its environment, so the two sources of truth cannot both be right.

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

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

Three short sentences, front-loaded with the core action and structured with a semicolon-separated clause list for the behavioural notes. No filler, though 'verified' and 'bounded' are used without definition.

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

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

An output schema exists, so return-value explanation is not required, and the description covers scope, evidence uncertainty, and the read-marking side effect. What is missing is the meaning of 'limit' (pagination/offset behaviour) and any indication of what 'bounded' means in practice.

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

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

Schema description coverage is 0%, so the description carries the full burden, yet it only gestures at 'All or Mentions tab' (mapping to the view enum) without naming the parameter. The required 'account' parameter and the 'limit' parameter are never explained, leaving most semantics to the bare 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 names a specific verb and resource ('Read ... X notifications') and scopes it to a 'verified All or Mentions tab', so an agent knows exactly what it fetches. It does not, however, distinguish itself from near-neighbours such as get_inbox or get_home_feed, leaving the sibling boundary implicit.

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?

'from a verified All or Mentions tab' and 'Results cover only the visible supported UI' imply prerequisites and scope conditions, and the side-effect warning about marking notifications read is a useful usage caveat. There is no explicit when-to-use guidance, no exclusions, and no named alternative (e.g. get_inbox) to route between.

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 openWorldHint=true, so the safety profile is covered. The description adds a behavioral detail by saying it reads 'using visible X page elements,' implying a UI-scraping or public-page approach, but it does not clarify auth needs, failure modes, or rate-limit 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?

The description is a single front-loaded sentence with no filler. It is structurally efficient, though it is arguably too terse for the amount of missing semantic 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?

An output schema exists, so return values need not be explained. But for a tool with two required, undocumented parameters and many sibling profile tools, the description is far too thin to tell an agent how to call it correctly or when to choose it.

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

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

Schema description coverage is 0%, and both required parameters are simply named 'account' and 'profile' with no descriptions. The description does not explain what either parameter should contain or how they differ, so it fails to compensate for the schema gap.

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

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

The description gives a clear verb and resource: 'Read public profile details.' However, it does not distinguish this tool from close siblings such as get_profile_context, get_profile_posts, get_profile_connections, or search_profile, leaving the agent to infer the boundary.

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

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

There is no when-to-use guidance, no exclusions, and no named alternatives. The sentence states what the tool does but gives no conditions that would help an agent choose it over the many other profile-related siblings.

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 openWorldHint=true, covering the safety profile. The description adds genuinely new behavioral context beyond them: that results are limited to visible public connections and are not a complete contact export, which shapes how an agent should interpret and trust the output. It stops short of covering pagination or rate limits.

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

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

Two tight sentences, with the core action front-loaded and the scope caveat immediately after. Nothing is redundant. It is efficient, though the extreme brevity leaves little room for the parameter and usage detail this tool needs.

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?

An output schema exists, so return values need not be explained. But for a four-parameter tool with 0% schema description coverage and no named alternatives, the description omits everything an agent needs to set account, profile, relationship, and limit correctly. Adequate only at the level of stating what the call does.

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

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

Schema description coverage is 0% across four parameters (account, profile, limit, relationship), and the description never mentions any of them. 'Followers/following' loosely hints at the relationship parameter's values, but nothing explains account vs profile, the limit default of 20, or how relationship selects direction. The description does not compensate for the total documentation gap.

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

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

States a specific verb and resource: read visible public followers/following for a profile. The scope qualifier ('public', 'visible') makes the data boundary clear. It does not name or contrast with near siblings like get_profile_context, get_profile_posts, or search_profile, so an agent still has to infer which profile-reading tool applies.

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

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

The negative framing ('not a private address book or complete contact export') usefully bounds expectations and implies this is for public connection listing only. However, it names no alternative tool and gives no condition for choosing this over the other profile-oriented siblings, leaving usage implied rather than specified.

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 openWorldHint=true, so the safety profile is covered. 'No draft or send' reinforces that this read triggers no writes, and 'bounded' hints at the post_limit cap, but neither adds much beyond the annotations and no return/rate/permission detail is given.

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

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

Two short clauses with the key framing ('Preferred outreach read') front-loaded and no filler. It is efficient, though terse to the point of under-specifying required inputs.

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?

An output schema exists, so return values need not be explained, and the read-only nature is clear. But with six-sibling overlap (get_profile, get_profile_posts, search_profile) and 0% param coverage, the description does not do enough to disambiguate inputs or tool choice for an outreach read.

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

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

Schema coverage is 0%, so the description must carry parameter meaning but does not. 'Profile details' and 'bounded authored posts' faintly gesture at profile and post_limit, yet the required 'account' parameter and the account-vs-profile distinction are never explained, leaving the agent to guess.

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 read: combining exact profile details with bounded authored posts. This implicitly distinguishes it from siblings like get_profile (details only) and get_profile_posts (posts only) by framing it as the combined 'outreach read'. The verb is implied rather than explicit, but the resource and scope are clear.

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

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

'Preferred outreach read' implies the context (outreach preparation) in which this tool should be chosen, and 'No draft or send' sets a boundary against action-taking siblings. However, it never names alternatives such as get_profile or get_profile_posts, nor states an explicit when-not condition, leaving the agent to infer 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?

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds genuinely new behavioral context beyond them: 'Results are bounded and partial,' warning the agent that output is truncated and not comprehensive — important for a scraping-style read.

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

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

Three terse fragments with the resource stated first, then the parameter values, then the result caveat. No filler, though the telegraphic 'feed: posts|replies|media' style is slightly clipped even for a tool 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?

The output schema exists, so return-format explanation is not required, and the partial-results caveat covers the main behavioral risk. But with 4 parameters at 0% schema coverage, the undefined 'account'/'profile' identifiers and the bound applied by 'limit' leave the agent under-informed for invocation.

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

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

Schema description coverage is 0% and the schema declares no enums, so the description's 'feed: posts|replies|media' is the only place the feed values are documented — real added value. However, 'account', 'profile', and 'limit' remain entirely unexplained in both schema and description.

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

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

States a specific verb and resource ('Read one author's posts') and enumerates the three feed variants it can return. It is distinguishable from get_profile in spirit, but never explicitly names what get_profile or search_profile cover, so the boundary is only implied.

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

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

No guidance on when to choose this over get_profile, get_profile_context, get_profile_connections, or search_profile — all siblings that touch the same author. The feed options hint at use cases but neither exclusions nor prerequisites are stated.

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

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

The description adds behavioral context beyond the readOnlyHint annotation: it reveals that omitting run_id returns all runs since boot, and it uses the verb 'poll' indicating non-blocking repeated calls. It also explicitly states 'Read-only' which aligns with the annotation.

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 extremely concise: three short statements with no wasted words. It front-loads the verb and resource, then specifies parameter behavior and read-only nature. Every sentence 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?

Given the tool has an output schema and one optional parameter, the description covers the key behavioral aspects: polling mechanism, parameter dependency for listing all vs. specific run, and read-only nature. It does not explain what a 'run_cycle handle' is, but the tool name and context likely make it clear.

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

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

The input schema has 0% description coverage for the run_id parameter. The description compensates by explaining the effect of omitting run_id (lists all runs since boot) and implies that providing it polls a specific handle. This adds crucial meaning beyond the schema's type and default.

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 'poll' and the resource 'run_cycle handles'. It specifies two behaviors: polling a specific run (when run_id given) and listing all runs since boot (when omitted). This distinguishes it from sibling tools like run_cycle (which likely initiates runs) and list_accounts.

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 tool is used to check status of run cycles, but it does not explicitly state when to use it versus alternatives like run_cycle or process_queue. It provides context about omitting run_id but no exclusions or scenarios where another tool would be preferred.

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 openWorldHint=false, so safety is covered. The description adds valuable context beyond that: it explicitly states what is NOT included (credentials, paths, identities, environment values) and warns that the returned configuration does not guarantee live authentication, which is a non-obvious behavioral caveat.

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 what it returns, then a compact list of what it excludes, then a usage caveat. No filler. Slightly dense but each clause carries distinct 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?

Given no parameters, an output schema exists (so return format needn't be described), and annotations cover safety, the description is nearly complete. It covers scope, exclusions, and a critical caveat about authentication. It could be slightly richer about execution mode semantics, but it is sufficient for correct invocation.

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

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

Zero parameters, so baseline is 4. The description correctly implies this is a parameterless inspection tool, and no parameter semantics are needed or missing.

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

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

States a specific verb (inspect) and enumerates the exact resources returned: server/package versions, tool count, execution mode, workflow support, unlock allowance. This distinguishes it from siblings like get_account_health and get_session_status, though it doesn't explicitly name those alternatives in the purpose sentence itself.

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

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

It gives a clear usage context through the negative constraint: 'without starting a browser' and clarifies the difference from get_account_health ('Configuration does not prove live X authentication; use get_account_health and a bounded read for that'). This is a strong when-not and alternative pointer, though it doesn't exhaustively cover when-not to use it vs other info tools.

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 openWorldHint=false, so safety is covered; the description nonetheless adds material behavioral context the annotations cannot convey. The caveat that 'ready' means locally usable transport rather than verified live X authentication, plus the legacy-backend 'unknown' case, is exactly the kind of nuance that prevents misreads.

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 front-loaded sentences that each carry distinct content: the state list, the 'ready' clarification, and the legacy-backend caveat. Dense but no filler sentences.

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

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

An output schema exists, so return-value explanation is unnecessary, and the description covers the state semantics and the important 'ready' caveat well. The remaining gap is parameter handling, which the definition leaves entirely to an undocumented schema field.

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

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

Schema description coverage is 0% and the single 'account' parameter carries no description in the schema. The description never mentions the parameter at all, so it fails to compensate for the low coverage by stating what the account selector does or whether it is optional for the default session.

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

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

States a specific verb (Inspect) and resource (local session lifecycle), and enumerates the exact states it reports, which is concrete and distinguishable. It does not, however, explicitly differentiate itself from siblings like get_account_health or get_runtime_info, which also report status-like information.

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 phrasing 'without reading cookies or starting a browser' implies the intended lightweight, local-only use case, but there is no explicit when-to-use or when-not-to-use guidance. It never names get_account_health or get_runtime_info as alternatives, leaving the agent to infer the boundary.

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

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

Goes well beyond the readOnlyHint/openWorldHint annotations by disclosing real behavioral traits: parent links are only known 'unless the page proves them,' results are 'partial, not a full archive,' and include_images caps at five photos/video posters with no server-side LLM or video transcription. These are exactly the operational caveats an agent needs.

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?

Purpose is front-loaded, followed by return caveats, the include_images behavior, and a usage hint. All four sentences carry information, though the include_images sentence is dense and could be split for readability.

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?

An output schema exists, so return values need not be enumerated, yet the description still signals partial results and unknown parent links. The remaining gap is the undocumented limit and account parameters for a four-parameter read 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 0% across 4 params, so the description must compensate. It explains include_images thoroughly (max five images, source mappings, no transcription) and implies tweet_url, but limit and account are left entirely uninterpreted.

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 and tightly scoped resource: 'Read bounded visible conversation context around one exact X post.' The scoping words 'bounded visible' and 'around one exact X post' distinguish this from single-post reads like get_tweet and from DM-style get_conversation without needing to name them.

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 explicit context for use: 'Read this before composing contextual replies or reply threads.' That tells the agent when the tool is appropriate, but it never names alternatives (get_tweet, search_tweets, continue_thread) or states 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=true and openWorldHint=false, so the safe-read profile is covered. The description adds that the data is 'durable local' state, consistent with openWorldHint=false, plus hints at what is returned. That is modest added context above the structured fields, but nothing about freshness, size, or error behavior.

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

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

A single short sentence, front-loaded with 'Read', with no filler. It is economical, though the telegraphic style mildly reduces readability for an unfamiliar resource.

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?

An output schema exists, so explaining return values is not required, yet the description spends its words on returns ('segment states, exact published URLs and next index') rather than the input meaning or the tool's role among siblings. For a parameterized, specialized read tool, the agent is left unsure what run_id is or when to call it.

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

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

There is exactly one required parameter, run_id, with 0% schema description coverage, so the description must supply its meaning. It does not mention run_id at all and never explains what identifies a run. Baseline relief for zero params does not apply here, leaving a real gap.

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 read verb and enumerates the returned artifacts (segment states, published URLs, next index), giving a partial sense of purpose. But it never says what a 'thread run' is or how it differs from siblings like get_run_status, get_thread, or continue_thread, leaving the resource ambiguous. Vague rather than specific.

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

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

There is no when-to-use guidance, no prerequisites, and no routing to alternatives such as get_run_status (current status) or get_thread (content). The agent must guess when this tool applies versus the many thread/run siblings in the list.

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

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

Annotations already declare readOnlyHint and openWorldHint. Description adds details on include_images effect, return content, and explicitly states no posting occurs, adding value beyond 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?

Very concise: one short paragraph with front-loaded purpose, followed by important nuance on include_images, and ends with a safety note. 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?

Covers main return items and behavior, output schema exists so full return details are documented elsewhere. Lacks error handling details, but acceptable for a simple read tool.

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

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

Schema coverage is 0%, so description must compensate. Only include_images is explained; account and tweet_url lack any description, leaving their semantics unclear.

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?

Clearly states it fetches one tweet and lists returned data: text, author, counts, media, persona. Distinguishes from write tools by noting 'Read-only' and 'Nothing is posted'.

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?

Implies use for fetching a single tweet, but no explicit when-to-use or alternatives. Does not distinguish from similar read tools like get_metrics.

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

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

Adds value beyond annotations by detailing secret stripping and that no browser is started, which are important behavioral traits not covered by readOnlyHint.

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?

Single sentence, front-loaded with key information, 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?

Given no parameters and existence of output schema, the description fully covers necessary context for a simple list 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?

No parameters exist, so baseline of 4 applies; no additional parameter information 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 clearly states the tool lists configured accounts with secrets stripped, distinguishing it from sibling get_account which returns details for a single account.

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?

Implies usage for viewing all accounts without secrets, but does not explicitly state when to use this tool versus alternatives like get_account or list_proxies.

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

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

Annotations already cover the safety profile (readOnlyHint=true, openWorldHint=false), and the description goes further by disclosing the pagination bounds (limit 1-100, with offset) and the set of valid campaign statuses. It stops short of explaining what 'local campaigns' scopes to or whether results are sorted/filterable by status.

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

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

Two short sentences, front-loaded with the resource and scope before the field/pagination details. The telegraphic status list and 'limit 1-100, with offset' are efficient, though the fragments read more like notes than prose.

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?

An output schema exists, so return values need not be described, but with 0% schema coverage the description should do more for a 4-parameter tool: it never defines 'local campaigns' versus membership, nor how status filtering interacts with pagination. Adequate but with visible 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 description coverage is 0%, so the description carries the param burden alone. It supplies the limit range and the four legal status values (draft, ready, paused, completed) — genuinely useful since the schema has no enum — but leaves 'offset' and 'account' semantics unexplained beyond their names.

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

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

States a specific verb (List) plus resource (this account's local campaigns) and adds a scoping qualifier '(without membership details)' that separates it from the heavier get_campaign family. It does not name a sibling explicitly, but an agent can tell it is the lightweight enumeration tool rather than the detail fetch.

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

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

There is no when-to-use guidance, no statement of when to prefer this over get_campaign, get_campaign_summary or list_leads, and no exclusions. Usage must be inferred purely from the verb 'List'.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the trailing 'Read-only' is redundant. However, the description does add real behavior beyond structured data: results are ordered newest-first and the limit is capped at 100, both of which the schema does not express.

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

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

One densely packed sentence, front-loaded with the verb and resource, then filter semantics in the order a caller encounters them. No filler sentences.

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

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

Low-complexity read tool with an output schema (so return shape needn't be explained), all three parameters documented, ordering disclosed, and safety covered by annotations. Only gap is behavior when more than 100 drafts exist (truncation vs. paging), which is not addressed.

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

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

Schema description coverage is 0% and the status parameter has no enum in the schema, so the description carries the full burden — and it does: it enumerates all seven status values, defines account as an account id, and states limit caps the response at 100. This is exactly the compensation a 0%-coverage schema needs.

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

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

States a specific verb + resource ('List drafts') and adds the default sort order ('newest first'), which no structured field carries. It does not explicitly differentiate from sibling readers like get_draft, but the singular/plural contrast makes the scope inferable. Clear, just not sibling-routing.

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 filter parameters imply when this tool is useful (narrowing by status or account), but nothing states when to use list_drafts versus get_draft, list_queue, or the draft-mutating siblings. Adequate but leaves selection to inference.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds 'No browser starts,' a genuinely useful behavioral trait (fast, no browser session) that is not derivable from the annotations or schema.

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

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

Three compact sentences, front-loaded with purpose then filters then behavior. Every clause carries information with no filler.

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

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

An output schema exists so return values need no explanation. For a filtered-list tool the description covers purpose, filtering, pagination bounds, and a behavioral note, leaving it essentially complete; only cross-sibling routing guidance is thin.

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

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

Schema coverage is 0%, so the description must carry the load, and it does: limit bounds (1-100), offset for pagination, status filtering, and 'exact tag' (clarifying exact-match rather than substring). It omits nothing critical, though account and default values are not addressed.

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

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

States a specific verb (List) and resource (this account's local leads), which lets an agent distinguish it from get_lead (single fetch) and upsert_lead. The 'local' qualifier hints at scope but is not explained, and no sibling is named explicitly.

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

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

The description implies when to use filters ('optionally filtering by status or exact tag'), giving actionable usage context. However it never states when to prefer this over get_lead for a single lead or how it relates to the lead-management siblings.

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, so the read-only aspect is covered. The description adds 'never starts a browser,' which provides additional safety context beyond annotations. No contradictions.

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 with no wasted words. Specific details (size, masked members, rotation cursor) are front-loaded, making the purpose immediately clear.

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 zero parameters, presence of output schema, and annotations covering read-only, the description fully covers the tool's behavior and return value, including the key safety note.

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?

No parameters exist, and schema coverage is 100%. The description adds no parameter info, but that's unnecessary. Baseline 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 uses the specific verb 'List' and clearly identifies the resource (proxy pools, strategy, assignments, fallback). It distinguishes from sibling tools like add_proxy, remove_proxy, test_proxy by being a comprehensive read-only listing.

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 read-only nature and comprehensive listing imply usage for viewing proxy configurations, but no explicit guidance on when to use vs alternatives. Sibling tools like add/remove are implicitly for modifications.

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 openWorldHint=false, but the description adds meaningful context beyond them: it will never start a browser, and it returns the exact payloads that would fire rather than just summaries. It does not discuss ordering or freshness of the queue data.

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

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

Three short clauses, front-loaded with the core purpose, followed by return shape and paging constraints. No sentence is filler.

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

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

An output schema exists, so return formatting is covered, and the description still communicates what the results contain (payloads + per-status counts). The only material gap is the undocumented status/account filter semantics for a 4-parameter 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 0%, so the description carries the burden, and it partially does: it documents limit (1-100) and offset (paging through local history). The 'status' and 'account' filters are undocumented in both schema and description, leaving half the parameters unexplained.

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

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

States a specific verb+resource ('List queued actions') and adds distinguishing scope: full payloads of what will fire, plus per-status counts. An agent can distinguish this from process_queue or cancel_queued_action without opening the schema.

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

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

Gives clear operating context ('Read-only, never starts a browser', limit/offset semantics for paging history), which tells the agent when this inspection tool is appropriate. It stops short of naming an alternative sibling (e.g. process_queue) or stating an explicit when-not-to-use condition.

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

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

The description goes well beyond the annotations, disclosing that delete cannot be undone locally, that it does not guarantee deletion for recipients, that approval is always required, and that only verified visible controls are supported. These are exactly the operational facts an agent needs for a mutation-bearing tool. Minor tension with destructiveHint=false, but since the tool only drafts and always requires approval, the annotation is defensible and not contradicted.

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

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

Two tight sentences: the action and its variants come first, the risk/approval caveats second. No filler, no repetition, and the most important constraint (irreversible delete, approval required) is front-loaded appropriately.

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 an output schema present, return values need not be explained, and the annotations plus the behavior caveats cover the safety profile well. The remaining gap is parameter meaning under 0% schema coverage, which the description did not close.

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

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

Schema description coverage is 0%, so the description carries full responsibility for the three parameters. It only echoes the operation enum in prose ('accept a request, mute/unmute, delete') and says nothing about what account or conversation_id mean or how they should be supplied, leaving two of three parameters undocumented.

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?

"Draft one inbox action" states a clear verb+resource and enumerates the concrete operations (accept a request, mute/unmute, delete), so an agent knows exactly what this does versus read siblings like get_conversation or get_conversation_controls. It stops short of a 5 because it names no sibling explicitly and the broad name 'manage_conversation' is only clarified, not contrasted.

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

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

Usage is implied by the enumerated operations and the caveats (approval required, only verified visible controls supported), but there is no explicit when-to-use/when-not guidance and no pointer to the alternative read tool (get_conversation_controls) that an agent might reach for. Adequate context, but the routing decision is left to inference.

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

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

Annotations already declare the mutation, idempotency, and non-destructiveness, so the bar is lower, and the description adds genuinely useful behavior: the suppression is permanent and it retroactively blocks already-prepared campaign deliveries, not just future drafts. It does not say whether or how the opt-out can be reversed, which is the one notable gap.

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

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

Two short sentences, zero filler, with the core effect ('permanently suppress outreach') front-loaded ahead of the consequence detail. 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?

An output schema exists so return values need no explanation, and the annotations cover the safety profile. The description adds permanence and blast radius, which is what an agent needs before a mutation; only reversibility and the relation to other lead-state tools are left unstated.

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

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

Schema description coverage is 0% for both required parameters, and the description contributes only 'this account's lead handle', which loosely binds account and lead_id to the opt-out target. It gives no identifier format, no hint that lead_id must reference an existing lead (see upsert_lead/get_lead), so it does not compensate for the coverage gap.

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

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

The description gives a specific verb ('suppress') and resource ('this account's lead handle'), plus the consequence scope ('blocks prepared campaign deliveries as well as future drafts'). An agent can tell this is not the same as update_lead_status or pause_account_actions, though no sibling is named to make the distinction explicit.

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

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

There is no when-to-use or when-not-to-use guidance and no alternative tool is mentioned, despite siblings like pause_account_actions, update_lead_status, and cancel_thread being plausible adjacency. The agent must infer routing on its own.

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

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

Annotations declare the write-safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=true), so mutability is already covered. The description adds useful behavioral context that the pause is durable and requires an explicit operator resume, but does not disclose required permissions, scope, or whether other actions are blocked. It adds some value beyond annotations without being rich.

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

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

A single front-loaded sentence with the verb, scope, and durability condition; it wastes no words and no critical information is buried.

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?

An output schema exists, so return values need not be explained. For a one-parameter durable mutation control, the description covers the core effect but omits the resume counterpart by name and the account parameter's expected format, leaving an agent to infer operational details.

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

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

Schema description coverage is 0%, so the single 'account' parameter is completely undocumented in the schema and the description is silent on it too. The parameter is likely self-explanatory, but the description does not compensate for the coverage gap with format or source 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?

States a specific verb (Pause), resource (browser actions), scope (durably), and clearly reads as a counterpart to the sibling resume_account_actions. The agent can distinguish this from resume_account_actions without opening either schema.

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

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

The description explains the pause is durable and persists until the operator explicitly resumes them, which implies context of use. However, it does not explicitly name resume_account_actions as the undo mechanism or state when to pause versus other control tools; the routing is implied by the verb pair rather than spelled out.

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 mutation (readOnlyHint=false) and open-world effects (openWorldHint=true). The description adds the draft mode behavior and the need for approval, which is useful context. However, it does not elaborate on other side effects or requirements, leaving open-world behavior somewhat vague.

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 extremely concise: two sentences with no wasted words. The first sentence covers purpose and parameter clarification; the second explains the critical draft mode behavior. Every sentence 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?

Given the tool has an output schema (not shown) and annotations cover safety, the description provides all essential context: purpose, parameter clarification, draft mode behavior, and cross-reference to approve_draft. No gaps for an agent to correctly select and invoke this 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 0%, so the description must compensate. It explicitly defines 'media' as local file paths and 'community' as target community id. The other parameters (text, account) are self-explanatory from the schema. This provides sufficient 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 clearly states the tool's purpose ('Post a tweet from an account') and explains specific parameters (media, community). It distinguishes from siblings by mentioning draft mode, but does not explicitly differentiate from similar posting tools like generate_and_post or reply_to_tweet.

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 guidance on draft mode: 'In draft mode (default) returns a draft for review and posts nothing; approve_draft(draft_id) executes it.' This tells the user when to use draft vs direct posting, but does not contrast with alternative posting tools.

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 only give a coarse profile (non-read-only, non-destructive, non-idempotent), so the description carries real added value: it discloses the skip rules, that running it mutates state by marking the campaign ready, and that no bulk sends, browser, scraping, or LLM calls occur. The write-to-non-idempotent combination is consistent with the annotations and is usefully explained.

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

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

Four dense sentences that front-load what is prepared before the safety caveats, with almost no filler. The single blemish is the trailing 'even when draft_mode is off', which spends words on a parameter that is not in the schema.

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

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

An output schema exists, so return values need not be described, and the description covers the mutation, the filtering rules, and the no-side-effect guarantees an agent needs before invoking. The unresolved 'draft_mode' reference and the total lack of parameter semantics are the only meaningful gaps for a 3-parameter 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 0%, so the description must compensate, yet it explains nothing about 'account' or 'campaign_id' and only partially touches 'max_messages' via 'at most 20'. Worse, it references a 'draft_mode' switch that does not exist among the three declared parameters, adding confusion rather than clarity.

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

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

States a specific verb and resource ('Prepare ... personalized private-message drafts') plus the target population ('eligible new/qualified leads on an active account'), so an agent knows exactly what is produced. It stops short of naming how it differs from the close siblings preview_campaign_message and prepare_outreach, so it is clear but not sibling-differentiating.

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

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

It supplies eligibility filtering rules ('skip opt-outs and prior pending/delivered members') and a downstream workflow ('review every exact payload and approve each draft individually'), which implies when to reach for it. However it never states when to use this instead of preview_campaign_message or prepare_outreach, and gives no explicit exclusions or prerequisites, leaving the routing decision to inference.

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

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

Annotations label this non-read-only, non-idempotent, non-destructive. The description adds substantial context beyond them: no server LLM is invoked, no message is sent, draft_mode does not bypass review, context is a bounded subset rather than full history, and opt-outs/activation are rechecked after the browser read. These disclosures meaningfully raise the bar on the annotated safety profile.

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?

Sentences are clipped but front-loaded and each earns its place, covering scope, caveat, side-effect boundaries, and review flow. It is terse to the point of feeling stitched together, but not padded.

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

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

For a 4-parameter, 3-required mutation-class tool with an output schema, the description covers the key non-obvious behavior: bounded context, no send, review requirement, rechecked eligibility. It omits parameter meaning for account/profile, but the critical operational and safety context is present.

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

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

Schema description coverage is 0%, so the description carries the full parameter burden. It explicitly defines the semantics of message_text ('your exact supplied text') and mentions a 10-post cap, but account, profile, and the default post_limit of 5 are never explained, leaving half the surface ambiguous.

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 bundles three actions (fetch profile, fetch posts, create draft) at unspecified granularity, making it hard to tell whether this is a research tool or a preparation tool. It doesn't distinguish itself from siblings like get_profile_context, preview_campaign_message, or prepare_reply.

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

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

It gives clear when-to-use guidance by naming get_profile_context as the research step to run first, and it states that the user must review then call approve_draft individually. What's missing is when to choose this over the many other prepare_* siblings.

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 readOnlyHint and openWorldHint. The description adds value by explaining what data is returned (tweet text, media as image content, account keywords, persona) and confirming no server-side LLM or posting. No contradictions.

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 efficient sentences: first sentence front-loads the purpose, second sentence specifies next steps. Every word earned its place with no filler.

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

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

Given the presence of an output schema, the description sufficiently covers the tool's purpose and usage flow. It explains the context provided and the required follow-up actions, making it complete for a preparatory tool.

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