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

Discloses all key behavioral traits: requires prior login, sets account as active, non-changeable currency, returns id and name. With no annotations, this description fully carries the transparency burden.

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

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

Five sentences, each serving a purpose: core action, prerequisite, side effect, return value, practical guidance. No wasted words, front-loaded with key information.

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

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

Covers prerequisites, side effects, return values (no output schema), and usage advice. For a simple create tool with three parameters, this is 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?

Adds significant meaning beyond the schema: for name, it mentions being shown on invoices; for email, receiving invoices; for currency, the 'cannot be changed later' constraint. Schema coverage is 100% but description enriches all params.

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

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

The description clearly states the tool creates a new billing account, a specific verb and resource. It distinguishes from sibling tools like accounts_list and accounts_use by focusing on creation and subsequent behavior.

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

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

Explicitly states when to use (after login, before project creation), when not to (check existing accounts first), and provides alternatives (accounts_list). The guidance about most users needing one account is valuable.

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, description adequately conveys read-only behavior and details the return fields (id, org name, billing email, currency, status, active flag). No contradictions.

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

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

Four sentences efficiently cover purpose, prerequisites, output, and next steps with no redundancy.

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

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

Given no output schema and no annotations, the description is nearly complete for a parameterless list tool. It covers return fields, prerequisites, and workflow context. Lacks mention of error cases or pagination but is sufficient.

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

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

No parameters, and schema description coverage is 100%. Baseline for zero parameters is 4, and the description adds value by noting the prerequisite login requirement, earning a 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 clearly states the tool lists billing accounts for the logged-in user, using specific verbs and resource naming, and distinguishes it from siblings like accounts_create and accounts_use by mentioning the 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?

Explicitly states prerequisite of prior login and suggests using accounts_use after listing. Provides clear context but does not explicitly state when not to use it beyond the implicit purpose.

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 full burden. It explains input format ('full UUID or a unique prefix'), output ('resolved account name and id, or an error'), and intended effect ('set active billing account'). It does not explicitly state side effects or idempotency, but given the simple nature, it is nearly complete.

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

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

Three sentences, front-loaded with purpose, then usage guidance, then input/output specifics. No redundant words; every sentence serves a distinct role. Excellent conciseness for a single-parameter tool.

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

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

Given the tool's simplicity (one param, no output schema, no nested objects), the description covers all necessary context: what it does, when to use it, how to provide input, what to expect as output. No gaps remain.

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

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

Schema coverage is 100%, so baseline is 3. The description essentially repeats the schema's parameter description. No additional meaning is added beyond what the schema already provides, though the usage context is helpful.

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

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

The description clearly states the action: 'Set the active billing account that project commands operate on.' It specifies the verb 'Set' and the resource 'active billing account'. It distinguishes from siblings like accounts_list (list accounts) and accounts_create (create accounts), making its unique purpose obvious.

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

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

Explicitly states when to use: 'after login when you belong to more than one account, before using projects_list, projects_create, or projects_use.' It also directs to accounts_list for valid IDs. Provides both procedural context and prerequisite knowledge, leaving no ambiguity.

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 description carries the burden. It discloses that destructive commands need '--yes' to skip confirmation, and suggests adding '--json' for machine-readable output. It warns against including 'anythink' or '--profile'. While it doesn't detail error handling, it covers key behavioral traits for a generic CLI runner.

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, well-organized paragraph. It starts with purpose, then usage guidance, followed by examples and important notes. Every sentence adds value; no unnecessary repetition.

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

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

Given the tool's complexity as a generic CLI runner, the description covers boundaries, examples, and important flags. With no output schema, it mentions returning output. Could mention potential errors or timeouts, but overall sufficiently complete.

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

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

Schema description coverage is 100% with a detailed parameter description that matches the tool description. The tool description adds extra usage examples and context (destructive commands, --json flag) beyond the schema, enriching 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 the tool runs any Anythink CLI command and returns output. It specifies the tool is for commands not covered by dedicated tools, listing examples like 'entities list' and 'data list posts', which distinguishes it from sibling tools.

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

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

Explicitly states when to use this tool: 'Use this for commands not covered by dedicated tools' and lists those tools (entities, fields, data, etc.). Provides examples and context for menu commands, making usage clear.

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

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

Despite no annotations, description fully discloses behavior: only removes local credentials and settings, does not delete project or revoke tokens server-side. Mentions return type (confirmation or not-found).

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

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

Four sentences, front-loaded with main action, no extraneous information. Each sentence serves a purpose.

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?

Fully adequate for a simple tool with one parameter and no output schema. Covers scope, side effects, and return messages.

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

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

Single 'profile' parameter is already described in schema, but description adds value by referencing 'config_show' for valid names. With 100% schema coverage, baseline is 3; extra context merits a 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?

Description clearly states it deletes a saved project profile from local CLI configuration. It distinguishes from sibling 'projects_delete' by clarifying scope.

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

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

Explicitly states when to use (remove local profile) and when not (server-side deletion), providing alternative tool 'projects_delete'. Also advises running 'config_show' to see valid profile names.

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 fully discloses behavior: reads local config, makes no network calls, returns specific fields for profiles (name, org id, auth method, alias, platform) and platforms (URLs, billing account, login status). No contradictions.

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

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

Two concise sentences. The first provides the core purpose and output; the second gives usage guidance and constraints. Every sentence earns its place with no redundancy.

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

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

Given zero parameters and no output schema, the description is complete. It covers purpose, output details, usage context, and safety (no network calls). No gaps remain.

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

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

No parameters, so baseline is 4. The description adds value by detailing the return structure, which compensates for the lack of an output schema.

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

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

The description clearly states the tool's purpose: 'Show the local CLI configuration: all saved project profiles and platform logins, and which of each is active.' It distinguishes itself from siblings like config_use and config_remove by focusing on display rather than modification.

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

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

Explicitly guides when to use: 'Use this to discover profile names for config_use, config_remove, or logout, and to check which project the cli tool currently targets.' Also notes it only reads local config with no network calls, implying safe to use without side effects.

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 fully carries the burden. It clearly explains the effect (switches the active profile for the cli tool), the prerequisite (profile must exist), and the outcome (confirmation or error if missing). It also mentions the non-destructive nature by noting no re-authentication needed, which implies safety.

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

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

The description is three sentences with no wasted words. It front-loads the action and scope, then provides usage guidance and error handling. Every sentence adds distinct value.

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

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

The description is complete for this simple one-parameter tool. It explains what the tool does, when to use it, prerequisites (profile must exist), how to find valid profiles (config_show), and what the output is (confirmation or error). No output schema is needed because the return is simple text described.

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

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

The input schema covers the single parameter 'profile' with a description, achieving 100% coverage. The tool description repeats the same parameter semantics ('must already exist', 'see config_show') but does not add new meaning beyond the schema. Thus, it meets the baseline of 3.

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

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

The description clearly states the verb 'Switch' and the resource 'active project profile'. It distinguishes from similar tools by noting it moves between already-connected projects without re-authenticating, and explicitly references the 'cli' tool and related commands like config_show and projects_use.

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

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

The description explicitly states when to use: 'to move between already-connected projects without re-authenticating'. It also states when not to use by emphasizing the profile must already exist, and directs the agent to run config_show to see available names. This provides clear usage context and alternatives.

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

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

No annotations provided, so description carries full burden. Discloses return of session token, but lacks details on side effects like session expiration, rate limiting, or invalidation of prior sessions. Adequate for a basic login tool but could be more 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 sentences with no extraneous information. Efficient and front-loaded.

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

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

Tool is simple, no output schema needed. Description covers purpose, inputs, and return type (session token). Complete for its complexity.

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

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

Schema coverage is 100%, parameters are simple (email, password) and self-explanatory. Description adds minimal value beyond schema, only hinting at return value. Baseline 3 is appropriate.

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

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

Description clearly states tool logs in with email and password and returns a session token. Distinguishes from sibling by mentioning alternative 'login_google' for Google sign-in.

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

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

Explicitly says when to use (email/password login) and provides alternative (login_google). Offers clear context 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?

No annotations are provided, so the description carries full behavioral burden. It discloses the core action (bypass billing login) but omits details like authentication requirements, side effects (e.g., persisting credentials), or error conditions. The description adds some value but is incomplete for a credential-storing 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 consists of two sentences, directly stating the purpose and usage condition. No unnecessary words or repetition. Perfectly front-loaded.

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

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

The tool has 5 parameters, no output schema, and no annotations. The description does not explain return values, whether credentials become active immediately, or how to verify success. It covers the core purpose but leaves behavioral gaps typical for authentication tools. Adequate but not 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 coverage is 100%, with each parameter having a description (e.g., orgId as 'Organization/tenant ID', apiKey as 'API key (ak_...)' ). The tool description adds minimal extra meaning beyond the schema, merely restating the condition for use. Baseline 3 is appropriate.

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

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

The description clearly states the tool's action ('store credentials directly for a project') and distinguishes it from the billing login process, implying a sibling tool for that purpose. The condition for use ('when you already have an org ID and API key or JWT token') is explicit.

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

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

The description provides explicit context for when to use this tool (when credentials are already available) and implies an alternative (billing login), but does not name sibling tools like 'login' directly or specify when not to use. This is clear but not exhaustive.

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 full burden. It discloses key behaviors: opens browser for Google consent, waits for user approval, stores session token. It also notes the stdio-only requirement. However, it omits potential error handling or timeout behavior, preventing a perfect score.

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 four sentences, each adding essential information: purpose, browser flow, what it does not do and next steps, and system requirement. No redundancy or filler.

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

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

Given the complexity of an OAuth login tool with no output schema, the description covers authentication flow, prerequisites (browser, stdio), and required post-login actions. It could additionally mention the return value or error scenarios, but is largely sufficient.

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

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

The input schema has zero parameters and the description fills in by explaining the whole process. The baseline for 0 parameters is 4, and the description adds meaning beyond the empty schema by detailing the browser interaction and follow-up steps.

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

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

The description clearly states the tool's purpose: 'Sign in to the Anythink platform with Google.' It identifies specific verb and resource, distinguishing from siblings like 'login' and 'login_direct' by specifying the Google OAuth method and clarifying that it does not handle account or project selection.

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

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

The description explicitly guides when to use the tool: after login, call accounts_list/accounts_use and projects_list/projects_use. It also warns against use on hosted HTTP server due to browser requirement, effectively telling when not to use it and providing follow-up steps.

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 fully carries the burden. It clearly states the tool only deletes the local stored profile and does not revoke the token or affect the project server-side. This is detailed and accurate.

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 concise, using only three sentences with no filler. It front-loads the main action and provides essential details efficiently.

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

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

Given the tool's simplicity (1 optional param, no output schema), the description fully covers purpose, usage, behavior, and parameter. No gaps remain.

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 sole parameter 'profile' is fully described in the schema, and the description adds value by noting it defaults to the active profile and referencing 'config_show' for names. This exceeds the baseline for 100% schema coverage.

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

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

The description clearly states the tool removes saved credentials from local CLI config, using the verb 'remove' and specifying the resource. It distinguishes itself from sibling login/logout tools by explicitly describing the scope (local profile only).

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

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

The description gives explicit use cases: 'disconnect from a project or clear a stale token'. It also clarifies what it does not do (no server-side revocation) and the default behavior when profile is omitted. However, it does not explicitly mention when not to use or alternatives.

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

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

With no annotations provided, the description carries the full burden. It discloses asynchronous provisioning, required billing account, and return fields (id, name, org id, API URL). It does not contradict any annotations (none present) and adequately covers behavioral traits for a creation tool.

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

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

The description is a single paragraph that is well-structured: main action, prerequisites, behavior, output. Every sentence adds useful information. It is appropriately sized for a creation tool with moderate complexity.

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

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

Given no output schema and no annotations, the description covers purpose, prerequisites, async behavior, and return fields. It addresses how to monitor progress and connect. It could mention error handling or billing failure scenarios, but overall it is fairly complete.

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

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

Schema coverage is 100%, and the description adds meaningful context beyond the schema: e.g., name is 'human-readable', planId references the 'plans' CLI command, region defaults to 'lon1', accountId defaults to active account, description as optional. This adds value without redundancy.

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

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

The description uses a specific verb ('Provision') and identifies the resource ('new project') with a clear definition as 'a dedicated, isolated Anythink backend instance'. It distinguishes from sibling tools like projects_list, projects_use, and projects_delete.

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 states prerequisites ('Requires platform login and an active billing account') and provides context on asynchronous behavior with polling instructions, along with a reference to connect using 'projects_use'. It mentions alternatives implicitly (accounts_use, projects_list) but does not explicitly state when not to use this tool.

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

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

Despite no annotations, the description fully discloses the destructive and irreversible nature, what gets destroyed (backend instance, database, data), prerequisites (active billing account), and return value (project name and id).

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

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

The description is three sentences, front-loaded with the critical action, and contains no unnecessary words. Every sentence adds value.

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

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

For a 2-parameter tool with no output schema, the description adequately covers behavior, prerequisites, and return value. Minor gap: no mention of error handling or what happens if prerequisites are not met.

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

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

Schema coverage is 100%, but the description adds meaningful context: explains that 'id' can be UUID, name, or unique prefix, and advises to use specific IDs and where to find them. For 'accountId', it clarifies defaulting behavior.

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

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

The description clearly states the tool's purpose: to permanently delete a project and its backend instance, database, and stored data. It differentiates itself from sibling tools (projects_create, projects_list, projects_use) by explicitly being the destructive deletion action.

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

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

The description provides clear usage guidance: confirm with the user first, prefer specific IDs over prefixes, and require an active billing account. However, it does not explicitly contrast with alternatives for non-destructive actions.

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

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

With no annotations, the description fully explains behavior: it is a read-only listing operation. It lists all return fields including statuses (Initializing/Provisioning/Active/Suspended/Terminated/Error), which is beyond the input schema. No contradiction.

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

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

Two efficient sentences with no wasted words. The main action is front-loaded, and the second sentence packs necessary details (return fields, prerequisites, usage flow) in a structured manner.

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

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

Given no output schema, the description comprehensively covers return values (fields and statuses) and prerequisites. It also integrates with sibling tools, providing a complete usage context for a list operation.

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

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

Schema description coverage is 100%, and the parameter's description already states it defaults to the active account. The tool description does not add new meaning about the parameter's format or constraints beyond the schema.

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

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

The description clearly states 'List the projects (provisioned backend instances) in a billing account,' using a specific verb and resource. It distinguishes from sibling tools by mentioning that the output is used with 'projects_use' and 'projects_delete'.

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

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

Explicitly states prerequisites: 'Requires platform login and an active billing account (set one with 'accounts_use').' Provides clear context on when to use: 'Use this to find a project's id before connecting with 'projects_use' or removing it with 'projects_delete'.'

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?

Discloses key behavioral traits: resolves project, stores or exchanges credentials, returns profile name/org/URL/auth method. No annotations exist, so the description carries the full burden and does so adequately, though it could mention if existing profile is overwritten.

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

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

Two efficient sentences with no wasted words. Front-loaded with the core action, followed by process details and prerequisites. Every sentence adds value.

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

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

Given no output schema and 3 params, the description covers purpose, prerequisites, behavior, and return values. It is complete for setting an active profile but could elaborate on output structure or side effects like overwriting.

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

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

Schema coverage is 100%, so baseline 3. The description adds little beyond what the schema already provides for each parameter, such as the automatic token generation for apiKey. No significant extra meaning is added.

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

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

The description clearly states 'Connect to a project and save it as the active profile' with specific verb and resource, and distinguishes from siblings like projects_create or projects_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?

It provides prerequisites (active billing account via accounts_use, project must be Active from projects_list) and the outcome (targets cli commands). However, it does not explicitly state when not to use or provide direct alternatives.

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

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

No annotations exist, so the description carries full burden. It discloses that account creation requires email confirmation, that login will not work until confirmed, and that it is a top-level identity creation without billing/project. This is transparent and aligns with mutation behavior.

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

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

A single paragraph with purposeful sentences, no redundancy. Front-loaded with purpose, then usage, then behavioral notes. Every sentence serves a function.

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 5 parameters, no nested objects, no output schema, the description covers purpose, usage, behavioral constraints, and post-conditions completely. No 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 100%, so baseline is 3. The tool description adds minimal extra context (e.g., email becomes login identifier, password should be strong), but does not significantly enhance understanding beyond the schema.

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

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

The description clearly states the verb 'Register' and the resource 'brand-new Anythink platform account with email and password'. It explicitly distinguishes from sibling 'login' by specifying when to use each (only when no account yet).

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

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

Provides explicit when-to-use and when-not-to-use: use only if no account, else use 'login'. Also specifies what the tool does not do (create billing/project) and directs to 'accounts_create' and 'projects_create'. Includes post-registration steps (email confirmation, then login).

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