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

没有提供注解，描述承担全部行为披露责任。'from memory' 提供了有价值的细节：清除的是本地内存状态而非服务端会话，这比泛泛的 'delete session' 更具体。但未说明清除后的后果（如是否需要重新认证）或返回行为。

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?

单句描述，信息密度高，无冗余词汇，结构和措辞均已最简化。

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?

工具本身极其简单（0 参数、无嵌套对象、有输出 schema），单句描述已覆盖核心行为。缺少与 auth_* 工具族其他成员的关系说明，但对这样一个无参数工具而言，描述已足够完整。

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?

工具无参数，input schema 为空对象，schema description coverage 为 100%，描述无需补充任何参数语义。根据 0 参数 baseline 4 分。

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

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

描述使用明确动词 'Clear' 和资源 'active session'，并注明作用范围 'from memory'，能清楚表达工具的功能。虽然未与兄弟工具显式对比，但足以和 auth_status、auth_refresh 等区分。

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?

描述隐含了使用场景——当需要清除当前认证会话时调用此工具，但没有说明何时不该使用，也未与 auth_finish、auth_refresh 等替代工具做任何区分。代理只能从工具名和单一描述句推断。

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

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

With no annotations, the description carries the full burden. It discloses that a session is activated (a side effect), but gives no details about token storage, idempotency, security requirements, or error behavior. For an OAuth token exchange, this is a significant transparency 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?

The description is a single, front-loaded sentence with no wasted words. It conveys the core action efficiently, though it omits depth. This is appropriately sized for a simple purpose statement.

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 this is an OAuth completion step with no annotations and no parameter documentation, the description is incomplete. It fails to explain the prerequisites (e.g., call auth_start first), the need for the state parameter, or the security-sensitive nature of exchanging codes. The output schema exists but does not replace this missing 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%, so the description must compensate. It only implicitly maps 'authorization code' to the code parameter, but does not explain the required 'state' parameter's purpose (e.g., CSRF protection) or the role of 'client_secret'.

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 ('Exchange'), a specific resource ('authorization code'), and a clear outcome ('activate session'). This distinguishes auth_finish from siblings like auth_start (which would begin the flow) and auth_set_access_token (which sets a token directly).

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention auth_start as a prerequisite or auth_set_access_token as an alternative, nor any condition that would select one over the other. The context is entirely absent.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. 'Poll' implies a non-destructive read, but the description does not clarify whether it blocks, times out, consumes the state, or has side effects. The output schema exists but does not cover behavioral traits.

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 focused sentence with no filler. The core action and target ('Poll pending OAuth state') are front-loaded, and every word contributes 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?

For a single-parameter tool with an output schema, the description plus schema is enough to make a basic call. However, it lacks lifecycle context—such as that the state likely originates from auth_start—and does not specify polling behavior like retry or timeout semantics. It is adequate but has clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate for the single 'state' parameter. It does partially by suggesting the state refers to a pending OAuth state, which adds useful context beyond the bare parameter name. However, it does not explain where the state value comes from or its expected format.

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

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

The description uses a specific verb ('Poll') with a clear resource ('pending OAuth state') and specifies the outcome ('callback status and auth code availability'). It is mostly distinct from siblings like auth_status, though it does not explicitly name a sibling to distinguish itself from.

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

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

There is no guidance on when to use this tool versus alternatives such as auth_start, auth_finish, or auth_status. The term 'Poll' implies it is used during an OAuth flow, but the description does not state prerequisites, sequencing, or 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?

With no annotations, the description must carry the full burden of behavioral disclosure. It only says the refresh token comes from session or argument; it does not mention whether the tool updates the session, what happens on invalid/expired refresh tokens, or any authentication or rate-limit considerations. This is a meaningful gap for an auth-mutating tool.

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

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

The description is a single, front-loaded sentence with no wasted words. It is concise and easy to parse, though so terse that it omits necessary context beyond the core action.

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 an authentication tool with no annotations and three undocumented optional parameters, the description is too sparse. It lacks when to call, session update behavior, and parameter dependencies. The output schema covers return values, but the invocation context is 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 description compensates only for refresh_token by stating it comes from session or argument. client_id and client_secret are left entirely unexplained — an agent cannot tell whether they are required, what they do, or how they interact with session defaulting.

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 (Refresh), a resource (access token), and the source of the refresh token (session or argument). This clearly distinguishes it from siblings like auth_start and auth_set_access_token in function, though it doesn't name them 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?

Usage is implied rather than stated: an agent can infer this tool is for refreshing an expired access token. However, there is no explicit when-to-use vs. alternatives, no mention of when not to use it, and no prerequisites (e.g., must have a session or valid refresh token).

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that the token is set as active, but does not mention whether this overwrites an existing token, persists across sessions, affects auth lifecycle, or what capability hints actually do.

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

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

The description is a single concise sentence with no filler or repetition. It is front-loaded with the primary action, though the vague 'capability hints' tail could be structured more clearly.

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 six parameters, zero annotations, and the existence of numerous auth-related sibling tools, this description is not complete enough. It does not explain the auth flow context, the meaning of capability hints, or which parameters are relevant for typical 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 description coverage is 0%, so the description must compensate. It identifies access_token and vaguely references 'capability hints', but does not explain the six parameters such as source, expires_at, member_urn, scopes_csv, or role_hints_csv, nor how they relate to each other.

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 clear verb (Set) and resource (active LinkedIn access token), and also mentions optional capability hints. It is distinguishable from siblings like auth_start/auth_refresh, but the 'capability hints' phrase is vague and could overlap with auth_set_role_hints.

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 is provided on when to use this tool versus alternatives such as auth_start, auth_refresh, auth_status, or auth_set_role_hints. The context of manual token injection versus the OAuth flow is entirely absent.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It reveals that the tool mutates role hints and that these hints affect capability gating, but it omits important traits such as whether the update is persistent, whether it replaces or merges existing hints, whether authentication is required, and what side effects occur. This is minimal disclosure for a state-changing 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?

The description is a single, direct sentence with no filler, front-loading the verb and resource. It is appropriately sized for a simple one-parameter tool, though the lack of additional context limits its usefulness.

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

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

The tool is simple (one parameter, no nested objects) and has an output schema, but the description leaves critical gaps: the CSV format is undocumented, the meaning of role hints is unstated, and there is no context about when this should be called in an auth flow. An agent cannot reliably call this tool correctly based solely on the provided description.

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

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

The schema covers 0% of parameter descriptions, and the description does not mention role_hints_csv at all. The parameter name implies a comma-separated list of roles, but the description adds no information about acceptable values, CSV structure, or ordering. This leaves the agent unable to construct a correct invocation without external knowledge.

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 'Update' with the resource 'role hints' and ties it to 'capability gating,' making the core operation clear. It is distinguishable from sibling tools like auth_set_access_token or whoami because it targets hint data rather than credentials or status. However, it does not explain what a role hint is, so it falls short of fully disambiguating the tool's role.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives such as auth_set_access_token or can_execute_tool. It implies the operation is for modifying capability-gating inputs, but does not state prerequisites, ordering, or scenarios where this tool is preferred. An agent must infer the appropriate context from the name and schema.

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?

Because no annotations are provided, the description must carry the full burden of behavioral disclosure. It mentions generating a URL and an optional localhost callback listener, but it does not disclose side effects such as whether existing auth state is replaced, whether a browser is opened, whether the listener blocks, or whether credentials are stored. This is a state-changing tool with minimal behavioral context.

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

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

The description is a single clear sentence with no fluff and is front-loaded around the main action. However, for a tool with five parameters, no required fields, and no annotations, it is under-sized and lacks the structure needed to convey usage and parameter guidance effectively.

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 is incomplete for an agent trying to invoke the tool correctly. It omits the overall OAuth flow context, the relationship to auth_poll/auth_finish, prerequisites, and the behavioral impact of optional parameters like open_browser and auto_listen_callback. The output schema does not compensate for the missing operational 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%, so the description must compensate for the five parameters. It offers only indirect hints: 'generating URL' could relate to redirect_uri, and 'optional localhost callback listener' hints at auto_listen_callback. It does not explain client_id, scopes_csv, open_browser, or redirect_uri meanings, leaving the agent without enough parameter-level understanding.

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

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

The description clearly states a specific action: 'Start OAuth authorization by generating URL and optional localhost callback listener.' This goes beyond the tool name by specifying the mechanism of how the flow starts, and it is clearly distinct from sibling tools like auth_poll, auth_finish, and auth_refresh, which handle later stages.

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

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

The description gives no guidance about when to use this tool relative to its many auth-related siblings. It does not mention that auth_poll or auth_finish should follow, nor does it describe prerequisites such as having a client_id or understanding the OAuth flow. Usage is only implied, not explicitly 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?

No annotations are provided, so the description carries the full burden. It only states what the tool returns, with no disclosure of whether authentication is required, whether it is non-destructive, or what happens if no session exists.

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

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

A single, front-loaded sentence with zero wasted words. Every word earns its place and the statement is immediately understandable.

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

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

For a zero-parameter tool with an output schema available, the description is mostly sufficient. The missing element is clarification of how this differs from whoami, but the low complexity and schema presence keep it reasonably complete.

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

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

The tool has zero parameters, so the baseline is 4. The description correctly needs no parameter explanations and the schema confirms an empty properties object.

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 'Return current session status' states a specific verb and resource clearly. However, it does not differentiate from sibling tools like whoami, which could also report session-related information, so it lacks explicit sibling 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?

No guidance is provided on when to use this tool versus alternatives such as whoami or auth_start. There are no context cues, exclusions, or usage scenarios mentioned.

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

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

No annotations are provided, so the description carries the full burden, and 'Check' does convey a read-only, predicate-like behavior. However, it does not disclose what the result means, whether the check is local or network-backed, or how 'scope' and 'role hints' are determined. There is no contradiction with annotations because none exist.

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 object appear immediately. It could convey more information without hurting readability, but as written it is appropriately compact and 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?

Complexity is low (one parameter, output schema present), and the description correctly focuses on the availability predicate rather than return values. The clear gap is the missing definition of 'scope' and 'role hints' and the relationship to sibling catalog/auth tools, which an agent would need to infer from 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%, so the description must carry parameter meaning, but it only gestureally implies that tool_name identifies the tool whose availability is checked. It does not clarify the expected format, whether names come from the tool catalog, or any constraints on the value. The single required parameter remains under-documented.

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

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

The description states a specific verb ('Check') and a concrete object ('whether a tool is available'), and it adds the conditioning context of 'current scope and role hints.' This distinguishes it from sibling listing and auth tools by topic, though it never names an alternative explicitly. Without that explicit sibling differentiation, 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 wording implies usage in a pre-invocation availability check tied to the current auth scope, but it never states when to prefer this over list_tool_catalog, auth_status, or list_capabilities, nor when not to use it. The usage context is present, but the guidance relies on inference rather than explicit direction.

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

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

With no annotations, the description carries the behavioral disclosure burden. 'Preview by default' is a useful disclosure that the default call is non-mutating, but the description omits important behavior such as authentication requirements, side effects of execute=true, and whether creation is irreversible. It is not misleading, only minimal.

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 with no filler, and the most important behavioral caveat is front-loaded. It is concise, though it sacrifices useful usage and parameter guidance for brevity.

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

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

Even though an output schema exists, the description is not complete enough for an agent to move from preview to actual campaign creation. It never explains how to trigger execution or populate body_json, and it gives no guidance about prerequisites or alternatives.

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 for undocumented parameters. It does not explain path, execute, or body_json, and only indirectly hints at execute=false through 'Preview by default.' An agent would not know how to structure a valid campaign creation request.

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 'Create ad campaign,' which identifies a specific verb and resource, and 'Preview by default' clarifies that the tool may run in a non-executing mode. It does not explicitly distinguish itself from sibling tools like create_campaign_group or update_campaign, but 'ad campaign' is reasonably distinct.

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?

'Preview by default' implies the default invocation is a dry run rather than an actual creation, giving some usage context. However, the description does not explicitly say when to use this tool over list_campaigns/update_campaign, nor does it state that execute=true is required to actually create a campaign.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals an important default behavior (preview rather than immediate creation), but omits side effects, authentication needs, how to actually execute, idempotency, or reversibility. This is insufficient for a mutation tool without annotation support.

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 with no filler, and the primary action is front-loaded. The second sentence adds meaningful behavioral information. However, the brevity mostly reflects under-specification rather than efficient completeness of guidance.

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

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

An agent cannot determine how to move from preview to actual creation, what a valid campaign group body should contain, or whether authentication is required. With no annotations and zero parameter documentation, the description is materially incomplete for invoking the tool correctly.

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

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

Schema description coverage is 0%, so the description needed to compensate for the three parameters. It does not explain `path`, `execute`, or `body_json`; 'Preview by default' only loosely maps to the `execute=false` default. No example values, body structure hints, or parameter relationships 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 states a specific verb ('Create') and resource ('campaign group'), making the core purpose clear and differentiating it from siblings like create_campaign or list_campaign_groups by name. The 'Preview by default' note adds useful behavioral context. However, it does not explicitly contrast with sibling tools beyond the name.

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

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

No guidance is provided on when to use this tool versus create_campaign, update_campaign, or list_campaign_groups. 'Preview by default' implies a dry-run mode but does not explain when execution should occur or what prerequisites exist. There is no mention of alternatives or exclusion conditions.

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

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

With no annotations present, the description carries the full disclosure burden and does reveal one consequential trait: 'Preview by default,' signaling that the default call does not mutate. However, it never explains what a preview returns, what execute=true does exactly, what side effects a real creation has, or whether authentication/scoping applies.

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 that front-load the action and immediately follow with the key behavioral qualifier. Every word contributes; nothing is redundant or 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 tool with three parameters, zero schema descriptions, and no annotations, the description answers 'what' but not the practical 'how': valid path values, body_json structure, and execute=true behavior are all omitted. An output schema exists, but it does not compensate for the missing parameter 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 must compensate. It loosely maps path ('endpoint path') and execute ('Preview by default') but says nothing about body_json — its format, required fields, or content — leaving a required parameter completely 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?

Uses a specific verb-resource pair ('Create comment') that distinguishes it from sibling tools like list_comments and create_post. The modifier 'at provided endpoint path' signals a path-driven creation model but does not obscure the core function. Clear enough for an agent to know what the tool does at a glance.

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 is given about when to choose this tool over alternatives such as create_post, create_reaction, or list_comments, and no prerequisites (auth state, existing post/comment) are mentioned. 'Preview by default' hints at invocation behavior but does not constitute usage guidance for tool selection.

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

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

With no annotations, the description carries the behavioral burden. It clearly discloses that the default action is a preview rather than an actual send, and that execute=true triggers the send. This is a key safety-relevant behavior. It does not discuss output shape or irreversible side effects, but the preview/execute split is meaningfully transparent.

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

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

Two short, front-loaded sentences with no filler. The core purpose appears first, and the critical execution behavior appears immediately after.

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

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

The description combined with the schema is enough to call the tool correctly: required params are visible, defaults are provided, and the preview/execute mechanism is stated. However, it omits what the preview response contains and does not explain the practical impact of visibility and distribution_feed defaults, with no annotations or output schema to fill those 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?

The description adds meaning only to the execute parameter ('set execute=true to send'). The required parameters author_urn and commentary, plus visibility and distribution_feed, receive no explanatory coverage. Since schema description coverage is 0%, the description must compensate more 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?

The description states a specific verb and resource: 'Create a simple text post.' This clearly differentiates the tool from siblings like create_comment, create_reaction, and the media-upload tools in the sibling list.

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 clear usage pattern: preview by default, and set execute=true to send. This tells the agent how to invoke the tool safely. It does not explicitly name alternative tools or exclusion conditions, but the resource is specific enough for basic selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose one meaningful behavioral trait: 'Preview by default,' indicating that execution is not immediate unless requested. However, it does not explain side effects, authentication requirements, or the effect of setting 'execute' to true, leaving significant behavioral gaps.

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

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

The description is extremely concise and front-loaded, with the primary action stated first and the preview behavior added in a single follow-up sentence. Every word contributes value, and there is no redundant or repetitive content.

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 is too sparse for a tool with three parameters, no annotations, and zero schema description coverage. While an output schema exists, the agent still lacks critical context about how to construct the reaction, what 'endpoint path' refers to, and what 'body_json' should contain. The description leaves too much to inference.

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 for missing parameter details. It only hints at the 'path' parameter and the 'execute' default behavior via 'Preview by default,' but it does not explain 'body_json' or clarify the expected format or relationship between the parameters. This is insufficient for a 3-parameter tool.

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

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

The description clearly identifies the action ('Create reaction') and the target ('provided endpoint path'), which distinguishes it from related sibling tools like list_reactions and delete_reaction. However, it lacks detail about what a reaction is or the domain context, 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?

There is no guidance on when to use this tool versus alternatives such as create_comment, create_post, or list_reactions. The only hint is 'Preview by default,' which implies a dry-run mode, but no explicit when-to-use or when-not-to-use criteria are provided.

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

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

With no annotations provided, the description carries the full behavioral burden, and 'Preview by default' is a genuinely valuable disclosure: it tells the agent that a default call is non-destructive and that actual deletion requires opting into execution. This is safety-critical context for a delete tool and goes beyond what the schema's default value alone conveys. It does not, however, mention irreversibility, cascading deletion of comments/reactions, or any special permissions needed.

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 totaling nine words, with the core purpose front-loaded and the critical behavioral caveat placed immediately after. Every word earns its place; there is zero 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 destructive tool with no annotations and 0% schema coverage, the description discloses the single most important trait (preview by default) and the output schema covers return values, so the agent is not entirely in the dark. But it omits the natural usage workflow (preview, then confirm with execute=true), the destructive consequences of execution, and any mention of auth or permissions. It is minimally adequate but leaves meaningful gaps for a delete operation.

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

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

Schema description coverage is 0%, so the description must compensate, and it partially does: 'by URN' clarifies that post_urn is the post identifier format, and 'Preview by default' explains the execute parameter's default behavior. However, it never explicitly states that setting execute=true is what triggers the actual deletion, leaving the key param semantics implicit. For a two-parameter tool, partial coverage of both params is 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 a specific verb and resource ('Delete a post by URN'), making the core purpose unmistakable even without opening the schema. It does not explicitly distinguish itself from sibling tools like create_post or delete_reaction, but no sibling competes for the same verb+resource pair. The 'Preview by default' clause introduces mild complexity about what a default invocation actually does, which slightly tempers clarity.

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

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

The description gives no guidance on when to use delete_post versus alternatives, and no exclusions or prerequisites (e.g., post ownership, auth requirements) are stated. 'Preview by default' hints at a preview-then-execute workflow but never tells the agent to run once with execute=false before confirming with execute=true. An agent must infer the invocation pattern 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?

With no annotations, the description carries the full behavioral burden. It discloses one meaningful trait — 'Preview by default' — signaling that no deletion occurs unless execute is set. However, it omits the destructive consequence when execute=true, any confirmation or idempotency behavior, and auth expectations, leaving the disclosure partial for a deletion tool.

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

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

Two sentences totaling roughly ten words, with the core verb-resource pair front-loaded. Every sentence earns its place: the first states the action and path semantics, the second states the default execution mode. No filler or redundancy.

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

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

For a simple 2-parameter tool with an output schema, the description covers the core action and the preview default, and the output schema relieves it of explaining return values. It falls short on when-to-use context and on warning about the destructive effect of execute=true, which matters more because no annotations exist to flag 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 description coverage is 0%, so the description must compensate for both parameters. It does add meaning: 'using full endpoint path' clarifies that path takes a complete endpoint rather than an ID, and 'Preview by default' interprets the execute parameter's default false. But it leaves ambiguity about the exact format of the full endpoint path and what execute=true does beyond the obvious implication.

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 ('Delete reaction') and adds the scoping detail 'using full endpoint path', making the tool's purpose clear. 'Preview by default' further clarifies the operating mode. No sibling performs reaction deletion, so explicit sibling differentiation isn't needed, though 'reaction' itself is a bit domain-ambiguous.

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 is given on when to use this tool versus alternatives, nor are prerequisites mentioned (e.g., whether authentication must be established first, especially given the many auth_* siblings). The 'Preview by default' note hints at a workflow but never states when the agent should actually set execute=true or when to prefer a different tool.

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

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

No annotations exist, so the description carries the full disclosure burden. 'Preview by default' adds real meaning by interpreting the execute=false default as a preview, but it stops there. The description fails to disclose whether finalizing is irreversible, what side effects occur when execute=true, or what the preview actually shows — a significant gap for a workflow-completing step.

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 phrases with zero filler, and the primary purpose is front-loaded before the behavioral note. It earns a strong score for efficiency, though the brevity trades away behavioral and parameter detail that the agent 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 don't need to be explained, but the description is otherwise incomplete for a tool with 3 parameters and no annotation coverage. An agent has no way to know the upload sequence, what to pass in path/body_json, or the consequences of setting execute=true. A finalization step with no safety information needs more context than this.

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%, yet the description adds almost nothing about the parameters. 'Preview by default' is the only hint, and it loosely maps to the execute boolean. The required path and body_json arguments are entirely unexplained, leaving the agent to guess what the path points to and what the JSON body must contain.

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 (finalize) applied to a specific resource (media upload workflow) scoped to image/video assets. The sibling set includes initialize_media_upload, so the initialize/finalize contrast is visible even though it isn't named explicitly. The main gap is that 'finalize' itself isn't concretely explained, but the purpose is clear enough to separate this from its siblings.

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

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

No guidance about when to call this tool versus alternatives. It doesn't say to use it after initialize_media_upload, mention prerequisites, or describe when preview mode is appropriate versus actually executing. The only hint, 'Preview by default,' describes an execution mode rather than routing an agent between 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?

With zero annotations, the description carries the full behavioral disclosure burden. The verb 'Fetch' implies a read-only operation, which is the only behavioral signal; nothing is said about authentication requirements, error behavior, pagination, or constraints on the query payload. The output schema covers return shape, but operational behavior remains largely undisclosed.

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 wasted words; the verb and resource appear immediately. The vague phrase 'custom query payload' costs a point, but the description is efficiently compact for what it does convey.

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?

Although the tool is structurally simple (two optional parameters with defaults and an output schema), the description leaves the core semantics undefined: what analytics are returned, what a valid query payload contains, and whether authentication is required. An agent could invoke it with defaults but cannot predict the meaning or scope of the result.

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 for the two undocumented parameters. It adds only that query_json is a 'custom query payload,' leaving its expected format and supported fields unexplained, and says nothing about the path parameter's role or how the two parameters interact.

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 ('Fetch') and resource ('ad analytics'), making the core operation clear. The phrase 'with custom query payload' adds the invocation mechanism, but it does not explicitly differentiate this tool from siblings like list_campaigns or list_ad_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?

No guidance is given on when to use this tool versus sibling tools such as list_campaigns, list_ad_accounts, or any auth_* tool. There is no stated prerequisite, no alternative-selection condition, and no mention of when this tool should not be used.

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

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

With no annotations, the description carries the behavioral disclosure burden. It partially meets it by naming the endpoints and implying a fallback to a member-specific endpoint when one is available. It does not cover auth needs, error behavior, or what happens with an empty member_urn, leaving clear gaps.

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

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

The description is one concise sentence with the main verb and object front-loaded. The second clause is somewhat ambiguous but compact, and there is no filler.

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

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

The tool has only one parameter and an output schema, but the ambiguous 'if provided' and silence on auth prerequisites and on omitted member_urn behavior leave real gaps. An agent cannot confidently invoke this tool without making external assumptions.

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 never mentions member_urn, its format, optionality, or how it maps to endpoint selection. The parameter name and title are self-describing, but the description adds no semantic value beyond the schema.

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

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

The description states a clear verb and resource ('Get member profile') and identifies the endpoint family (/v2/userinfo or member-specific endpoint). It does not explicitly distinguish this from sibling whoami, but the resource and endpoint orientation make the purpose recognizable.

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

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

The description gives no guidance about when to use this tool versus alternatives like whoami, nor does it explain auth prerequisites or when member_urn is needed. The phrase 'if provided' hints at conditional behavior but does not state a decision rule.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It only says 'Get', hinting at a read operation, but does not state side-effect-free behavior, authentication needs, error behavior, or response characteristics.

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?

'Get a post by URN.' is a single, front-loaded sentence with no wasted words. For a one-parameter read tool, this is appropriately concise.

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

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

The tool is simple and has an output schema, so the description does not need to explain return values. However, with no annotations and no usage guidance, the description lacks enough behavioral and selection context to be fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. 'by URN' tells the agent that post_urn is the identifier used to select the post, adding some meaning beyond the raw schema, but it does not provide format details, examples, or where the URN comes from.

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 ('Get'), resource ('post'), and selection mechanism ('by URN'). It distinguishes itself from siblings like create_post, delete_post, and list_comments by signaling a single-item read operation.

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

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

The description gives no guidance on when to prefer this tool over alternatives such as linkedin_get or when not to use it. It implies the obvious context — retrieving a post by URN — but offers no exclusions or comparisons.

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

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

With no annotations present, the description must carry the behavioral disclosure burden. 'Preview by default' hints at a default execution mode, but the description does not clarify what preview means, what side effects occur, whether the upload is actually initiated, or what happens when 'execute' is 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?

The description is short and front-loaded, with no filler words, and both sentences carry relevant information. However, it is so sparse that it omits essential structuring details about the workflow and parameters, making it concise but not appropriately sized for a 3-parameter initialization 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?

The output schema may cover return values, but the description still leaves critical gaps: what path and body_json contain, what 'Preview by default' means, and how this step connects to finalize_media_upload. An agent cannot confidently invoke this tool correctly from the provided description and schema alone.

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 explain the meaning of path, body_json, and execute. It does not define any of them; 'Preview by default' vaguely aligns with the execute default in the schema but adds no semantic value 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 states a specific action ('Initialize') and a specific resource ('media upload workflow for image/video assets'), making the tool's basic purpose clear. It does not explicitly differentiate itself from the sibling finalize_media_upload, but the word 'Initialize' implies the first step of a two-phase workflow.

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 no guidance about when to use this tool versus alternatives. No mention is made of finalize_media_upload, prerequisites, or the relationship between the initialize and finalize steps, leaving the agent to infer the workflow ordering.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It only notes that the tool is 'authenticated', implying an auth token is required, but it does not disclose rate limits, error handling, pagination, response format, or whether the GET is read-only. This is minimal behavioral context for a tool that could hit arbitrary endpoints.

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 at five words, with the key differentiator 'raw' and the HTTP verb 'GET' front-loaded. Every word contributes to the core purpose, but the word 'helper' is somewhat vague and could be replaced with more specific guidance. Overall it is appropriately sized for its limited scope.

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

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

Despite the presence of an output schema, the description leaves crucial gaps: it does not state the base URL, how path should be formatted, how query_json maps to request parameters, or how authentication is supplied. For a generic raw helper with three parameters and no annotations, this is incomplete and would require an agent to guess or inspect other tools.

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 for parameter meaning. It does not explain 'path', 'query_json', or 'api_version' beyond what their names imply. The 'GET' context hints that path is an endpoint and query_json may be query parameters, but no details are provided about formats, defaults, or how the API version 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?

The description states 'Raw authenticated GET helper', which clearly identifies the tool as a low-level helper that performs an authenticated GET request. This differentiates it from the specific sibling tools like list_campaigns or get_post, which are higher-level wrappers. However, it does not mention the LinkedIn API resource scope explicitly, relying on the 'path' parameter to imply that.

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 is provided about when to use this raw helper versus the many specific sibling tools. The word 'raw' implicitly suggests using it when no higher-level tool exists, but this is not stated. There are no exclusions, prerequisites, or alternative routing instructions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does state that the request is authenticated, which is useful, but it does not mention potential side effects, whether the POST is idempotent, required permissions, rate limits, or error behavior. This is a significant gap for a mutating 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?

The description is extremely short, which is concise in length, but it under-specifies to the point of being unhelpful. While it has no wasted words, it also lacks essential structure and content needed to understand the tool's purpose and parameters.

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

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

Despite having an output schema, the description is too minimal to support correct invocation. It omits parameter details, end-user expectations, and behavioral context. For a low-level helper with three parameters, the description provides far too little context, making the tool difficult to use safely and accurately.

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 explain the parameters, but it does not. It fails to clarify that 'path' is the endpoint path, 'body_json' is the request body, or 'api_version' is the API version. The schema only provides field names and defaults, leaving the agent without meaningful parameter semantics.

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

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

The description 'Raw authenticated POST helper' clearly identifies the action (POST) and the scope (authenticated requests), which is distinct from the sibling tools focused on authentication and listing campaigns. However, it does not specify which LinkedIn resource or endpoint is targeted, so it is clear but lacks full sibling differentiation.

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

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

No guidance is provided about when to use this tool versus alternatives. There is no mention of conditions, exclusions, or preferred use cases. The only implied usage is from the name and description, which is insufficient for an AI agent to decide between this and the sibling 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?

With no annotations, the description carries the full burden of behavioral disclosure. It states the tool 'lists' organizations and mentions 'admin-like roles,' but does not clarify whether authentication is required, what 'accessible' entails, whether the operation is read-only, or how it handles the single path parameter.

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

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

The description is a single concise sentence that states the core purpose immediately. It wastes no words, though its brevity contributes to the lack of behavioral and usage detail.

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

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

The tool is simple and an output schema exists, so return values are covered. However, the description omits behavioral context such as auth requirements, the role semantics, and the meaning of the path parameter. It is minimally complete but lacks helpful guidance for an agent operating in a larger tool suite.

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

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

The schema has one optional parameter 'path' with a default value, and description coverage is 0%. The description does not explain the purpose of the path parameter or whether it should ever be changed, leaving the agent without meaningful guidance beyond the default value.

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

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

The description uses a specific verb 'List' and resource 'organizations', and qualifies with 'where current user has admin-like roles,' clarifying that it returns organizations the user can access. It is distinct from sibling tools like list_campaigns or auth tools, though it does not explicitly name an 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?

No explicit guidance is given about when to use this tool versus alternatives, nor any exclusions or prerequisites. The intended use is implied by the name and description, but the agent is left to infer that it should be used after authentication and when organization-level access is needed.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. The parenthetical reveals an approval requirement but does not state what happens when approval is missing (error vs. empty list), whether authentication is needed, or any pagination/rate-limit behavior. The output schema partially covers return values, but critical operational behavior is left undisclosed.

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 very short and front-loaded, which is structurally efficient. However, the vague parenthetical raises an important question about approval requirements without answering it, making the text feel under-specified rather than deliberately concise.

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

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

The tool is simple (one optional parameter) and has an output schema, which eases the return-value burden. However, the approval gate is a central usage barrier that is entirely unexplained—an agent cannot determine how to satisfy it, what failure looks like, or which sibling tool to consult first.

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 adds no meaning to the single 'path' parameter beyond what the schema already provides via its default value '/rest/adAccounts'. The description fails to compensate for the schema's lack of parameter 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?

'List ad accounts' is a specific verb plus resource, clearly conveying the tool's core action and distinguishing it from sibling tools like list_campaigns and list_capabilities. The parenthetical '(approval-gated capability)' introduces a constraint hint but does not obscure the primary purpose.

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

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

No guidance is given on when to use this tool versus alternatives or what prerequisites exist. The approval-gated note implies access limitations but never explains how to check approval (e.g., via can_execute_tool) or whether authentication via the auth_* siblings is required first.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'List' implies a read-only operation, but the description does not mention authentication requirements, pagination, response shape, or any side effects. It adds little beyond what the tool name already conveys.

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 short sentence with no wasted words. However, it largely restates the tool name and adds minimal value, so it is concise without being substantive. Front-loading is not an issue given its brevity.

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

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

The tool has an output schema and two optional parameters with defaults, so basic invocation is inferable. But with no annotations, no usage guidance, and no parameter semantics in the description, the definition is not complete enough for an agent to reliably select and invoke this tool in the right 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%, and the description provides no explanation of the path or query_json parameters. The schema shows defaults like '/rest/adCampaignGroups' and '{}', but the description does not clarify how query_json should be structured or what values path accepts. With 0% coverage, the description must compensate and fails to do so.

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: 'List ad campaign groups.' This is clear and identifies the resource as ad campaign groups, which helps distinguish it from the sibling list_campaigns at a basic level. However, it does not explicitly differentiate campaign groups from campaigns or other list operations.

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 is provided about when to use this tool versus alternatives like list_campaigns, create_campaign_group, or the auth-related tools. The description merely states what it does, leaving the agent to infer appropriate usage from the name and 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?

With no annotations, the description carries the full behavioral burden, but it only says 'List,' implying a read operation. It does not disclose authentication needs, pagination behavior, filtering semantics, or any side effects. The output schema helps with return shape, but behavioral expectations are largely unspecified.

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 with no filler. The core action and resource are front-loaded, and every word earns its place.

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

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

For a tool with no annotations, undocumented parameters, and a nontrivial query_json input, the description is too thin. The output schema provides return structure, but the agent still lacks enough context to know how to construct a valid request or when this tool is the right choice.

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, but it adds nothing about how 'path' or 'query_json' should be used. The defaults suggest an endpoint path and a JSON query, yet no explanation, examples, or parameter-level semantics are provided 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: 'List ad campaigns.' It clearly distinguishes from create/update/delete campaign operations and from list_campaign_groups, though the distinction from campaign groups is only implicit in the noun 'campaigns' versus 'campaign groups.'

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 is provided on when to use this tool versus alternatives like list_campaign_groups or get_ad_analytics. There are no stated exclusions, prerequisites, or conditions that would help an agent choose it over sibling 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states it returns capabilities based on session hints, which suggests a read-only operation, but provides no detail about side effects, session dependencies, error cases, or how hints affect the result. It adds some behavioral context beyond the name but lacks depth.

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

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

The description is a single concise sentence that front-loads the verb and resource. It is appropriately sized for a zero-parameter tool, with no redundant phrases or filler. The only minor shortfall is that it could have briefly elaborated on what constitutes 'effective capabilities' without bloating the text.

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 zero parameters, an output schema exists, and the description states the primary purpose, this is nearly complete. It doesn't explain how session hints are set or retrieved, but that is covered by sibling tools like auth_set_role_hints. The absence of usage guidance and behavioral detail is a small gap but not critical for a stateless query 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?

The tool has zero parameters, so the input schema carries no burden. The description's mention of 'session hints' is the only substantive semantic content, and it clarifies the context the capabilities depend on. For a zero-parameter tool, this is adequate, though a slightly richer explanation of 'effective capabilities' would have pushed it to 5.

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

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

The description 'Return effective capabilities for current session hints' clearly states a specific verb (Return) and resource (effective capabilities for current session hints), which is distinct enough from sibling tools. It could be more explicit about what 'capabilities' means, but it differentiates reasonably well from tools like auth_status or list_tool_catalog.

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 in the context of the current session hints, making it clear this is a read-oriented introspection tool for capabilities. However, it does not explicitly state when to use this versus alternatives like list_tool_catalog or can_execute_tool, nor does it mention 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?

With no annotations, the description carries the full burden of behavioral disclosure. It indicates a listing/read operation, but does not mention authentication requirements, pagination behavior, error conditions, or how the optional query_json affects results. This leaves meaningful behavioral gaps.

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

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

The description is a single concise sentence with an illustrative example; there is no unnecessary verbosity. It is appropriately short, though the brevity contributes to missing semantic detail elsewhere.

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

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

Even with an output schema relieving the need to describe return values, the description does not explain the optional query_json parameter or provide any context about pagination, scoping, or required setup. For a tool with two parameters and no annotations, this is not complete enough for an agent to call it correctly in varied cases.

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. The 'path' parameter is partially explained through the example URL, but 'query_json' is completely unexplained despite having a default value. The description adds some meaning for path but not enough for safe invocation.

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 ('List') and resource ('comments for a resource path'), and provides a concrete path example. It is understandable and obviously distinct from sibling tools like create_comment or list_reactions, though it does not explicitly differentiate itself from 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?

No guidance is given about when to use this tool versus alternatives, nor are any exclusions or prerequisites mentioned. The example path hints at how to construct the resource path, but there is no explicit context for choosing this tool.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only says 'list,' which implies read-only, but does not disclose whether this reads a persisted manifest, requires authentication, or returns live vs. cached coverage data. It also doesn't describe any failure or side-effect behavior beyond the verb itself.

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 compact sentence with no filler. The actionable verb is front-loaded and every remaining word contributes meaning, making it easy to scan.

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

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

For a zero-parameter list operation with an output schema present, the definition is nearly complete. The main gap is the ambiguity of 'scaffold,' which leaves room for uncertainty about what exactly is being enumerated and how it relates to drift tracking.

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

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

The tool has zero parameters and schema description coverage is 100%, so there is no parameter burden for the description to carry. Baseline of 4 is appropriate because the description doesn't need to explain arguments that don't exist.

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 ('endpoint coverage scaffold') with a clear purpose ('for drift tracking'). However, 'scaffold' is somewhat jargon-y and the description does not contrast it with sibling listing tools such as list_capabilities or list_tool_catalog, so it falls 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 'for drift tracking' implies when the tool is useful, giving some contextual guidance. But it provides no explicit when-not-to-use guidance or alternatives, and with several list-style siblings available, the agent must infer which tool is appropriate.

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

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

No annotations are provided, so the description carries the full burden. It only says 'List', implying a read operation, but gives no information about authentication requirements, pagination, response shape, or edge-case behavior. This is minimal disclosure for an operation that likely hits an API endpoint.

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 focused sentence that front-loads the action and resource, and the example earns its place by clarifying the path format. It is concise without padding, though it could be slightly richer without hurting clarity.

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 tool with an output schema and only two parameters, the description is minimally viable: an agent can likely call it correctly using the path example. But the query_json parameter is unexplained, and there is no guidance on when this tool is preferred over related list tools, leaving clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented parameters. It clarifies the 'path' parameter format with an example, but says nothing about 'query_json', leaving a required-by-default parameter underspecified beyond the schema's bare name and default value.

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

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

The description names a specific verb ('List') and resource ('reactions for a resource path') and provides a concrete endpoint example. This makes the tool's purpose unambiguous and clearly distinguishes it from sibling tools like list_campaigns.

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 it should be used when an agent needs reactions associated with a resource path, and the example reinforces that. However, it provides no explicit when-to-use or when-not-to-use guidance and does not mention alternatives such as list_campaigns.

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

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

No annotations are provided, so the description carries the full burden. The verb 'List' implies a read-only operation, but the description does not disclose whether authentication is required, whether the catalog reflects dynamic capabilities, or any rate limits. For a metadata tool, this is a modest but present 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?

A single, front-loaded sentence with no filler. Every word contributes 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?

For a simple zero-parameter listing tool with an output schema, the one-sentence description is adequate. It could mention what fields the metadata contains, but the output schema likely covers that.

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

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

The tool has zero parameters, and the schema is fully covered at 100%, so there is nothing for the description to add. Baseline 4 for a zero-parameter tool applies.

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

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

Description states a specific verb ('List') and resource ('tool capability metadata'), and adds the audience ('approval-aware clients') which hints at the tool's purpose. However, it does not distinguish itself from siblings like list_capabilities or list_endpoint_manifest, so an agent might struggle to choose between them without opening schemas.

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

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

No guidance is given on when to use this tool versus alternatives. The phrase 'used by approval-aware clients' implies a context but does not explicitly state when an agent should invoke it or when it should prefer list_capabilities, list_endpoint_manifest, or can_execute_tool.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does add one useful trait—'Preview by default'—but it does not explain what preview returns, whether setting execute=true actually mutates the campaign, whether changes are reversible, or what permissions are required.

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 appropriately short and front-loads the key default behavior in the second sentence. However, it is so terse that it approaches under-specification rather than efficient completeness.

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

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

For a mutation tool with no annotations and minimally documented parameters, the description is incomplete. It does not explain the body_json payload shape, how path should be formatted, the role of execute, or what the output schema represents. The output schema existing helps, but the operational context is still missing.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters. It does not define path, body_json, or execute beyond restating that updates happen. 'Campaign fields' hints at body_json's content but provides no structure or format 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?

The description states a clear verb and resource: 'Update ad campaign fields.' It is reasonably distinct from sibling tools like create_campaign and list_campaigns, though 'fields' is somewhat vague about which fields are updatable.

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 guidance is given about when to use this tool versus alternatives such as create_campaign or list_campaigns. The 'Preview by default' hint implies a dry-run workflow, but it never states when a preview is appropriate or when an actual update should be executed.

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?

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It implies a read-style resolution operation and notes that the endpoint is configurable, but it does not disclose authentication requirements, failure modes, or how the path parameter is interpreted. This leaves key behavioral aspects unexplained.

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 sentence with no redundant words. It is front-loaded with the core action and includes the key configurable aspect concisely.

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

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

The tool is relatively simple: one optional parameter, an output schema, and a low-complexity operation. The description is adequate for basic understanding but lacks usage differentiation and behavioral context. It does not explain when to prefer this tool over related auth/profile tools, or clarify the profile endpoint resolution.

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 for the single 'path' parameter. The phrase 'configurable profile endpoint' gives some meaning to the path parameter, indicating it is the endpoint used for resolution. However, it does not clarify whether the path is a relative URL, absolute URL, or how it relates to the default '/v2/userinfo'.

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 a specific action, 'Resolve current principal', and identifies the resource as the current authenticated principal. It also mentions the configurable profile endpoint, which adds useful context. However, it does not explicitly distinguish this tool from siblings like auth_status or get_member_profile.

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 no guidance on when to use this tool versus alternatives such as auth_status, get_member_profile, or auth_refresh. There is no mention of exclusions, prerequisites, or preferred scenario. The agent is left to infer usage from the tool name and context.

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