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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond annotations: the result is 'bounded' (limited in scope/count) and credentials are not exposed. This goes beyond the structured hints.

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 tight sentence that front-loads the core action ('Read the latest bounded owner audit events') and appends key qualifiers ('for the linked project', 'without exposing credentials'). Every phrase 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?

Tool is simple with one optional parameter, an existing output schema, and annotations covering read-only/idempotent behavior. The description covers what is read, the source scope, and a security guarantee. Nothing critical is missing for an agent to invoke this tool correctly.

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

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

Schema description coverage is 100%, so the single optional 'path' parameter is fully documented in the schema. The description itself does not mention the path parameter or add any extra semantic details, placing this at the baseline for good 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 states a specific verb ('Read'), a specific resource ('owner audit events'), and the scope ('latest bounded', 'for the linked project'). It clearly distinguishes this from siblings like micro_logs or micro_deployments, and the additional 'without exposing credentials' clarifies the tool's safe purpose.

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

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

The description conveys a clear use case: reading the latest bounded owner audit events for the project. It gives context about when to use it, but does not explicitly mention alternatives or when not to use it, such as naming micro_logs for general logs or micro_usage for usage data.

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

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

Annotations already indicate this is a mutating, non-idempotent, non-read-only operation. The description adds meaningful behavioral context by specifying that the snapshot is 'bounded', 'transactional', and excludes authoritative identity, payment, entitlement, product, file, and deployment resources. This clarifies scope beyond the raw readOnlyHint/idempotentHint flags. No contradiction with annotations.

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

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

Two sentences with no filler. The core action and resource are front-loaded, and the exclusion list is given in a compact second sentence. Every word adds useful constraint 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?

Given the annotations, full parameter schema, and presence of an output schema, the description covers the key behavioral boundary (record-only snapshot with explicit exclusions). It could go slightly further by noting the relationship to restore/delete backups, but nothing essential to invoking the tool correctly is missing.

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

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

Schema description coverage is 100%, so the schema fully documents the two parameters ('path' and 'confirm'). The description adds no parameter-specific semantics, but the schema already carries that burden. Baseline 3 applies.

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

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

The description states a specific verb ('Create'), a resource ('bounded transactional snapshot of the linked project's records'), and the key boundary (excludes identity, payment, entitlement, product, file, and deployment resources). This clearly differentiates the tool from restore/delete/list backup siblings without needing to open 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?

The description provides clear context: use it when you want to create a record-only snapshot of the linked project. It does not explicitly name alternatives like micro_backup_restore or micro_backup_delete, but the create/backup semantics and exclusion list make the intended use obvious. It lacks an explicit when-not-to-use statement.

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

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

Annotations already mark this as destructive, but the description adds meaningful context: the deletion is permanent, applies to exactly one record-only backup, and does not mutate current project data or local source. This goes beyond the annotation signal and sets clear safety expectations.

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

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

A single sentence carries the core action, the scope, the permanence, and the safety boundary. It is front-loaded with 'Permanently delete' and contains no redundant words.

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

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

Given destructive annotations, complete schema descriptions for all parameters, and an existing output schema, the description is sufficiently complete. It tells the agent what is deleted, that deletion is permanent, and what remains untouched, which is all an agent needs to decide whether to invoke it.

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

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

All parameters are already well-described in the schema (backupId, sha256, confirm, path), so no heavy lifting from the description is required. The description's 'one exact' and 'record-only' wording loosely reinforces the backupId and sha256 parameters, but adds no syntax or behavioral detail beyond the schema.

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

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

The description states a specific verb ('Permanently delete'), a precise resource ('one exact record-only backup'), and explicitly scopes what it does NOT affect ('without changing current project data or local source'). This distinguishes it from micro_record_delete and micro_backup_restore even without naming alternatives.

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

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

The description implies when to use the tool: when the goal is to permanently remove a record-only backup, not to alter current data. However, it does not explicitly name alternatives or state when not to use it, such as pointing to micro_backup_restore for recovery or micro_record_delete for deleting live records.

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

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

Annotations already mark the tool destructive and non-idempotent, and the description adds meaningful context: it replaces all current records, requires both digests to guarantee exactness, and explicitly excludes users, purchases, entitlements, products, files, and deployments from rewinding. This goes beyond the structured hints without contradicting them.

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

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

Two dense sentences front-load the action and requirements with no filler. The second sentence efficiently captures the main exclusions and safety condition.

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 restore operation, the description covers what is replaced, what is never touched, and the exact preconditions. With an output schema present and full parameter documentation, it does not need to explain return values, though it could name where to fetch a fresh digest (e.g., micro_backups).

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

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

Schema description coverage is 100%, so the schema already documents every parameter. The description reinforces the relationship between backupSha256 and expectedCurrentSha256 as required twin digests, but it does not add substantial meaning beyond the schema.

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

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

The description uses a specific verb and resource: 'Replace all current project records with one exact inspected backup,' and clearly scopes what the operation affects and excludes. This distinguishes it from sibling backup tools like micro_backups, micro_backup_create, and micro_backup_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 the required preconditions (backup digest plus a freshly inspected current-record digest), so an agent knows when it is safe to call the tool. However, it does not name or contrast alternatives such as micro_rollback or micro_backup_create, leaving the when-not-to-use guidance implicit.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds valuable behavioral context beyond these flags by noting the backups are 'bounded transactional,' include a 'fresh digest,' and explicitly exclude users, purchases, entitlements, products, files, and deployments. No contradiction with annotations.

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

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

Two compact sentences with the primary verb 'Read' front-loaded. Every clause carries meaningful information about scope and exclusions, with no filler or repetition.

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

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

For a single-optional-parameter read-only inspection tool with a full output schema, the description sufficiently explains what is returned and what is excluded. Annotations cover the safety profile, so the agent has all essential information to invoke 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?

Input schema coverage is 100%, and the schema already describes the path parameter as the Micro project directory with a default. The description adds no additional meaning for this parameter, so the baseline score of 3 applies.

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

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

The description begins with a specific read verb and names a precise resource: 'bounded transactional project-record backups' plus the 'fresh digest of the current record set.' It clearly distinguishes itself from mutation siblings like micro_backup_create, micro_backup_restore, and micro_backup_delete, and the exclusion list further pinpoints what the data covers.

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

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

The read-only intent is clear, but there is no explicit guidance about when to use this tool versus alternatives such as micro_backup_create or micro_backup_restore. The usage context is implied by the verb 'Read' and the sibling names, not directly stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the description does not need to restate those. The description adds meaningful behavioral context by guaranteeing that payment credentials and card data are not exposed, which is valuable privacy-related information beyond the annotations.

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

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

The description is a single, compact sentence that front-loads the core action and resource, then adds a critical privacy qualifier. Every word earns its place with no redundancy or filler.

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

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

For a zero-parameter read-only tool with an output schema available and comprehensive annotations, this description is complete. It tells the agent what the tool does, what it protects, and implies the appropriate read-only context without requiring additional explanation.

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 there is no parameter semantics burden on the description. The description appropriately focuses on the operation itself rather than parameter details. A baseline of 4 is appropriate for a no-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 uses a specific verb ('Read') and a specific resource ('authenticated account subscription state'), making the tool's purpose immediately clear. It also distinguishes itself from sibling billing tools like micro_billing_checkout and micro_billing_portal by emphasizing it does not expose payment credentials or card data.

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

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

The description clearly indicates this tool is for reading subscription state in a safe, non-sensitive way. It does not explicitly name alternative billing tools or state when NOT to use it, but the read-only framing and privacy guarantee provide sufficient contextual guidance.

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

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

Annotations already indicate this is a non-read-only, non-idempotent mutation. The description adds valuable behavioral context beyond annotations: the session is hosted and does not accept payment credentials, which clarifies the boundary of what the tool can and cannot do. No contradiction with annotations 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?

Two short sentences carry all essential information with no filler. The primary action and scope are front-loaded, and the clarifying limitation about payment credentials is placed in a natural second sentence.

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 small parameter count, existing output schema, and annotations, the description covers the key behavioral distinction and the hosted nature of the checkout. It does not explain what 'inspected' means or address how the resulting session is used, but nothing required for basic invocation is missing.

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

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

The schema documents the confirm parameter reasonably, but the plan parameter only has a pattern and no semantic description. The description's phrase 'one inspected Micro plan' adds some context for the plan parameter, but no additional detail about parameter values or relationships is provided, so the compensation is partial.

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

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

The description uses a specific verb and resource: 'Create a hosted checkout session for one inspected Micro plan.' It clearly distinguishes this from generic billing tools by adding 'hosted' and 'does not accept payment credentials.' The purpose is immediately unambiguous.

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

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

The description implies the tool is for creating hosted checkout sessions for a single inspected plan, and it warns that payment credentials are not accepted. However, it does not explicitly name alternatives like micro_billing_portal or state when to prefer this over them, leaving some routing to inference.

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

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

The annotations already indicate this is a non-read-only, non-idempotent operation, and the description adds that the operation is hosted by Stripe. It does not disclose side effects, prerequisites, or external dependencies beyond the phrase 'hosted Stripe', so the added transparency is modest.

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 filler, front-loading the action and resource before the scope. 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 zero-parameter operation with an output schema, the description is sufficiently complete: it states what is created, the provider, and the target account. Return-value details are not required because an output schema is present.

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

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

The tool has zero parameters, and the baseline for no-parameter tools is 4. The description adds the relevant context that the session is for the authenticated account, so no parameter documentation is needed.

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

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

The description clearly identifies the verb and resource: it creates a hosted Stripe billing-management session for the authenticated account. This is more specific than the title, but it does not explicitly distinguish this from closely named siblings such as micro_billing_checkout or micro_billing.

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 select this tool over micro_billing or micro_billing_checkout, and there are no alternative routing cues. The only contextual clue is the authenticated-account scope, which is not enough to guide agent selection.

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

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

The annotations already declare idempotentHint=true and destructiveHint=false, so the key safety profile is covered. The description adds the important behavioral qualifier that this operation compiles and validates but does not deploy, which goes beyond the annotations and helps agents avoid expecting deployment side effects.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently conveys the action, target, and an important exclusion while remaining immediately scannable.

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 optional parameter, a 100% documented schema, an output schema, and annotations covering idempotence and destructiveness. The description adequately explains the tool's purpose and key non-behavior, so nothing essential is missing for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, with the single 'path' parameter fully described in the input schema. The tool description does not add parameter-specific meaning, but since the schema already documents the parameter, 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 states a specific verb ('Compile and validate') and a specific resource ('the conventional Micro project'), and explicitly clarifies that it does not deploy. This clearly distinguishes it from the many deployment-related sibling tools such as micro_deploy.

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 'without deploying it' gives an explicit exclusion that helps an agent understand when this tool is appropriate rather than micro_deploy. It does not name alternative tools or state exact conditions, but the context is clear enough 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?

Annotations already establish a mutating, non-idempotent, open-world operation, and the description adds genuinely new behavioral context: the build-then-validate pipeline and atomic apply semantics before the create-or-update lands. This does not contradict the annotations; atomicity is consistent with destructiveHint=false and openWorldHint=true. It omits the safety-gate behavior hinted by acceptLiveProducts/acceptPriceChanges, but the disclosure it does make is meaningful.

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

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

A single 10-word sentence with verbs front-loaded ('Build, validate, and atomically create or update') and zero filler. Every element — build, validate, atomic, production, create/update — carries informational weight and earns its place.

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

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

An output schema exists, so return-value documentation is unnecessary here. However, for a production deployment tool with two safety-guard booleans at 25% schema coverage, the description leaves an agent guessing about what acceptLiveProducts and acceptPriceChanges actually gate. It also fails to clarify how this relates to micro_build or micro_rollback. The functional core is present but the guardrail semantics that safe deployment depends on are not.

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 only 25% — solely 'path' has a prose explanation in the schema, while the required 'slug' and both boolean flags are bare. The tool description explains none of the four parameters, leaving the non-obvious acceptLiveProducts and acceptPriceChanges flags (which likely gate risky deployments) completely opaque. With coverage this low, the description was obligated to compensate and did 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 action chain — 'Build, validate, and atomically create or update' — on a specific resource ('a production Micro project'), which is far more informative than a bare verb+noun. The 'production' qualifier and the create-or-update semantics implicitly distinguish it from siblings like micro_build, micro_dev_start, and micro_preview. It does not explicitly name a sibling, which keeps it just shy 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 word 'production' implies this is the deploy-to-prod tool and the build+validate+upsert chain differentiates it from micro_build and micro_dev_* , but no explicit when-to-use or when-not-to-use guidance is given. No alternatives are named and no exclusions or preconditions are stated. Usage is implied rather than instructed.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds useful context by describing the history as 'immutable' and scoping it to 'the linked project,' which reinforces the read-only, non-destructive behavior beyond the bare annotations.

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

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

The description is a single, compact sentence that front-loads the core action and resource. Every word contributes meaning, and there is no redundant or filler 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?

For a simple read-only list tool with one optional parameter and an output schema, the description is sufficiently complete. It conveys scope and the immutable nature of the data; the output schema handles return-value details.

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

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

The schema covers 100% of the single optional parameter 'path' with its own description, so the baseline is 3. The tool description does not add additional meaning to the parameter beyond the schema.

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

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

The description uses a specific verb ('List') and resource ('deployment history'), and adds the 'immutable' qualifier, which clearly distinguishes this from sibling tools like micro_deploy. It clearly states what the tool does and what scope it operates in.

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

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

The description implies the tool is for reading deployment history and is read-only, but it does not explicitly state when to use it over alternatives such as micro_deploy or micro_rollback. It provides no exclusion criteria or when-not-to-use guidance.

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

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

Annotations already provide idempotentHint=true and destructiveHint=false, and the description adds meaningful transparency by disclosing that the runner is loopback-only, disposable, and official. This goes beyond the structured hints without contradicting them, though it doesn't detail side effects such as building artifacts or background process behavior.

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

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

The entire description is one tightly packed sentence with zero filler. Key qualifiers ('loopback-only', 'disposable', 'official') earn their place and the core action 'Build and start' is front-loaded.

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

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

For a simple two-parameter tool with an output schema and safety-relevant annotations, the description is mostly complete: it identifies the artifact, its network scope, and its lifecycle. It could be stronger by explicitly linking to micro_dev_stop or clarifying when to prefer micro_deploy, but these are not blockers.

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 only 50%: path is documented, but port has only a default and numeric bounds with no explanatory text. The description does not compensate by explaining either parameter. For a tool with half its parameters undocumented, this is a significant gap.

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

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

States a specific action ('Build and start') and a specific resource ('official loopback-only disposable Micro runner for this project'). This clearly separates it from siblings like micro_build (build-only), micro_deploy, and micro_preview by emphasizing the local disposable runner 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 conveys local development context with 'loopback-only' and 'for this project', making it clear this is the local dev runner rather than a deployment or remote operation. It does not explicitly list when-not-to-use or name alternatives, but the context is sufficient to guide selection among 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?

Annotations already carry the full safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false), and the description aligns with them — 'Read' matches the read-only nature with no contradiction. Beyond the annotations, the qualifier 'bounded' usefully signals that log output is intentionally limited rather than a full stream, and 'managed local Micro runner' identifies the exact target process, both of which add behavioral context the structured fields do not.

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 beginning with the action verb 'Read', with zero filler — every word ('bounded', 'local', 'managed') carries signal. The length is proportionate to a one-optional-parameter, fully-annotated read tool that also has an output schema.

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

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

With full annotations, complete parameter schema coverage, and an output schema present, the description correctly avoids explaining return values or safety basics. The only genuine gap is that it does not note whether a local runner must already be started (e.g., via micro_dev_start) for reads to succeed, which an agent would have to infer from sibling names — a minor omission for a simple read tool.

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

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

Schema description coverage is 100%: the single optional path parameter is already documented as 'Micro project directory; defaults to the server working directory'. The description's 'local Micro runner' loosely maps to this parameter but adds no syntax, format, or behavioral detail beyond the schema, so the high-coverage baseline of 3 applies.

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

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

The description names a specific verb ('Read') and resource ('bounded process status and logs for the managed local Micro runner'), making the tool's job immediately clear. The qualifiers 'local' and 'bounded' implicitly separate it from broader siblings like micro_status, micro_logs, and micro_platform_status, though no alternative is named explicitly, so it stops just short of 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?

The 'local Micro runner' phrasing implies this tool is for local development inspection, which an agent can infer alongside lifecycle siblings like micro_dev_start and micro_dev_stop. However, there is no explicit statement of when to prefer this over micro_status, micro_logs, or micro_platform_status, and no exclusions or alternative routings are given. Usage context is left to inference.

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

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

The description adds meaningful behavioral context beyond the annotations: 'gracefully' implies a clean shutdown rather than a forced kill, and 'managed local Micro runner' clarifies the target and scope. The idempotentHint and destructiveHint annotations already cover safety, and the description does not contradict them.

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

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

A single, front-loaded sentence states the action, manner, target, and scope with zero wasted words. Every part of the description 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 simple, one-parameter, idempotent stop operation with a full output schema and comprehensive annotations, the description is complete. The optional path parameter and the meaning of 'graceful' are the only context needed, and both are covered.

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

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

Schema description coverage is 100%, so the single optional 'path' parameter is already fully documented in the schema. The description does not add parameter-level detail, but it does not need to because the schema carries that burden.

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 ('stop') and identifies the resource ('managed local Micro runner for this project'), making the tool's function unambiguous. It clearly distinguishes itself from micro_dev_start and micro_dev_status without needing to open any schema.

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

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

The description makes clear this is for stopping the local development runner for the current project, which signals the appropriate usage context. It does not explicitly enumerate alternatives or exclusion conditions, but the scope and action are clear enough that an agent can decide when to invoke it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is well covered. The description adds useful scope detail about what is checked, but it does not explain behavioral aspects such as authentication requirements, network access, or what constitutes 'readiness' beyond the listed components.

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, well-structured sentence immediately states the action and enumerates the full scope of the check. There is no redundant filler, and every listed item adds information about what the doctor verification covers.

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 no parameters, strong safety annotations, and an output schema, the description is largely sufficient for an agent to understand the tool's purpose. It could be slightly stronger by stating that this is the recommended first diagnostic step when environment/setup issues are suspected, but the core context is 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 and schema coverage is 100%, so there are no parameter semantics to clarify. According to the rubric, a no-parameter tool warrants a baseline of 4; the description reinforces the value by listing the environmental components inspected.

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 uses a specific verb ('Check') and enumerates exactly which resources and environment pieces are inspected (CLI, compiler, runner, platform, owner account, local project). It is clear, but it does not explicitly differentiate itself from sibling status/readiness tools such as micro_status, micro_dev_status, or micro_platform_status.

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

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

No guidance is given about when to run micro_doctor versus the many status-related sibling tools. The description implies a general readiness/environment check, but it does not state when this tool is preferred or what distinguishes it from 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?

Beyond annotations, the description discloses a non-obvious behavioral detail: the tool only registers the hostname and returns proof that the user must publish externally. The word “normalized” also hints at input processing. No contradiction with annotations.

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

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

One tightly written sentence with no filler. Every phrase adds meaning: single hostname, normalization, DNS ownership proof, and the required publication step.

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 core operation is clear, but the description omits the relationship to micro_domain_verify and leaves “normalized” undefined. While schema and output schema cover some gaps, the DNS workflow context is incomplete for a tool sitting next to verify/remove siblings.

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

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

The hostname parameter has no schema description, and the description partially compensates by saying “one normalized hostname.” However, it does not explain the required DNS format or constraints, and the optional path parameter is not mentioned in the description. With 50% schema coverage, this is only partial compensation.

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 (“Register”), names the resource (“one normalized hostname”), and specifies the output (DNS ownership proof). This distinguishes it from related domain tools like micro_domain_verify and micro_domain_remove even though it does not name them.

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

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

There is no explicit when-to-use or when-not-to-use guidance and no mention of the related domain tools. “Must be published” hints at a follow-up step, but it does not say to use micro_domain_verify after publishing, nor when to prefer this tool over list/remove/verify.

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

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

Annotations already signal destructive, non-read-only, and idempotent behavior. The description adds the exactness constraint and project scope, which is useful context, but it does not go beyond that to describe side effects or consequences of removing the domain.

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 to identifying the operation, and the key qualifier 'one exact' appears early.

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 and annotation hints cover return values and safety, so a short description is acceptable for this simple delete-like operation. However, the lack of explicit guidance on how to find the domainId or when to use this versus domain management siblings leaves a moderate gap.

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 path and confirm with descriptions, and the domainId is reasonably inferable from its name and UUID constraints. The description's 'one exact custom domain' adds high-level meaning but does not directly explain how to obtain or supply domainId.

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 ('Remove'), names the resource ('custom domain'), and adds a precise qualifier ('one exact') plus scope ('linked project'). This clearly distinguishes it from sibling tools like micro_domain_add, micro_domain_verify, and micro_domains.

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 the use case: removing a single exact custom domain from the linked project. It does not explicitly name alternatives or state when not to use this tool, so the agent must infer routing from the sibling tool names and the removal context.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so the safety profile is covered. The description adds the useful detail that DNS proof state is included in the result but does not disclose behaviors such as error cases, project-link requirements, or output shape beyond that.

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 tight sentence with no repetition of the title or schema. It front-loads the action and resource and earns its place by adding 'DNS proof state' to what is returned.

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 read-only list command with one optional parameter, a full output schema, and rich annotations, this description is sufficient for an agent to select and invoke the tool. The only behavioral details not spelled out, like the meaning of DNS proof states, are covered by the output schema.

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

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

The single optional 'path' parameter is fully described in the input schema, including its default behavior, so the description does not need to repeat it. The description adds no parameter-specific meaning, which is acceptable given 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 names a precise verb ('List') and a clear resource ('the linked project's custom domains and DNS proof state'), distinguishing this read tool from management siblings such as micro_domain_add, micro_domain_verify, and micro_domain_remove. The scoping to the linked project makes it unambiguous what this tool returns.

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

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

The description clearly implies this is the tool to use for viewing custom domains and DNS proof state, but it does not explicitly state when not to use it or point to alternatives like micro_domain_verify for verification or micro_domain_add for adding domains. Usage context is implied rather than stated.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false. The description adds useful conditional-activation context beyond the annotations, but it does not explain what activation entails, what DNS record is checked, or how failures are reported. No contradiction with annotations.

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

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

A single front-loaded sentence that communicates both the verification action and the conditional activation. Every word earns its place, with no filler or repetition.

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

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

For a tool with annotations and an output schema, the core behavior is captured. However, the description omits practical context such as expected DNS record type, whether the domain must already exist, and any side effects beyond 'activate'—leaving an agent to infer those details.

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

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

Schema description coverage is 67%, with domainId and confirm already well-described in the schema. The tool description does not add any parameter-specific meaning, so it neither compensates for the uncovered path parameter nor significantly improves on the schema.

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

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

The description uses a specific verb ('Check') and names the exact resource ('the exact domain's DNS proof'), also stating the activation side effect. It clearly distinguishes itself from related tools like micro_domains, micro_domain_add, and micro_domain_remove.

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 conditional 'activate it only when ownership resolves correctly' gives some behavioral guidance, but the description does not explicitly state when to choose this tool over sibling tools or mention prerequisites like the domain having already been added. Usage context is implied rather than explicit.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior, so the description's main contribution is the explicit privacy guarantee that message bodies and provider credentials are never returned. This adds meaningful behavioral context beyond the annotations without contradicting them.

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

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

Two sentences deliver the core purpose, scope, and a critical privacy constraint with no filler. The most important information is front-loaded, and every sentence earns its place.

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

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

For a low-complexity, single-optional-parameter read-only tool with an output schema and rich annotations, the description covers the essential context: what is listed, whose data is included, and what is intentionally withheld. Nothing critical is missing for an agent to call it correctly.

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

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

The single parameter 'path' is already fully documented in the input schema with its default behavior, so the description adds no additional parameter semantics. With 100% schema coverage, the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('List') with a clear resource ('Micro project email deliveries') and defines the exact scope: owner-only delivery status and daily quota usage for verified-user notifications. This clearly distinguishes it from generic listing tools in the sibling set like micro_usage or micro_logs.

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

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

The description gives clear context for when the tool is relevant: checking delivery status and quota for verified-user project notifications, restricted to owner-only data. It does not explicitly mention alternatives or exclusions, but the use case is evident from the phrasing.

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

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

Annotations already establish read-only, idempotent, open-world, and non-destructive behavior. The description adds meaningful behavioral context beyond annotations: the data is 'live' and the manifest is 'not a transactional snapshot,' which helps an agent understand consistency guarantees. No contradiction with annotations.

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

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

Two sentences with no wasted words. The primary action and result are front-loaded, and the caveat is placed second where it reinforces safe interpretation without diluting the main 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?

For a simple read-only inspection tool with one optional parameter, rich annotations, and an output schema, the description is fully sufficient. It tells the agent what the tool returns, how consistent the data is, and the annotation profile covers safety and side effects.

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 single optional 'path' parameter is already fully explained in the schema. The description adds no parameter-level detail, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('Read'), a clear resource (the export manifest), and the specific information it returns (resource counts and pagination limits). This distinguishes it from siblings like micro_export_page and micro_status, which are about different resources or actions.

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

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

The description clearly implies when to use the tool: when the agent needs live export resource counts and pagination limits. It also adds a caveat ('not a transactional snapshot'), warning against relying on it for consistent point-in-time reads. It does not explicitly name alternatives, but the context is sufficiently clear.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds 'bounded' and 'live' context, which conveys pagination limits and current-data semantics beyond the annotations. It does not fully describe pagination behavior or ordering, but the annotation coverage lowers the 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?

The description is a single front-loaded sentence with no filler. It efficiently communicates the action, resource types, and pagination nature. Every word contributes to the core meaning.

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

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

An output schema exists and annotations cover safety, so return details are not required in the description. However, the description omits practical usage context such as how path, limit, and offset interact, and it does not clarify when to choose this generic paging tool over resource-specific sibling tools. It is adequate but not 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 low at 25%, and the tool description only enumerates the resource enum values, duplicating the schema enum. It gives no real guidance for path, limit, or offset beyond the word 'bounded' hinting at pagination. The description does not compensate enough for the underdocumented parameters.

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

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

The description states a clear action and resource scope: 'Read one bounded live page of project users, records, purchases, entitlements, products, files, or audit events.' It identifies the specific verb and the pagination behavior ('one bounded live page'), which distinguishes it from a full export tool. However, it does not explicitly differentiate it from sibling resource-specific tools like micro_users or micro_purchases.

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 such as micro_users, micro_records, or micro_export_manifest. The description implies a paging use case but provides no explicit when-to-use, when-not-to-use, or alternative routing. This is a significant gap given the large sibling tool set.

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

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

Annotations already cover read-only, idempotent, open-world, and non-destructive behavior. The description adds useful context that no content is downloaded and that both protected and public resources are included. It does not mention pagination, recursion, or ordering, but this is acceptable given the annotation coverage.

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 that front-loads the action, resource, and scope. Every word contributes: listing, protected/public, storage resources, linked project, and no content download. There is no filler or repetition.

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

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

This is a low-complexity tool with one optional parameter, an output schema, and safety annotations already provided. The description is sufficient for an agent to call it correctly. A brief note about alternative tools would improve completeness, but nothing essential is missing.

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

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

There is only one optional parameter and the schema description coverage is 100%, so the description does not need to add much. The 'path' parameter is already documented in the schema, and the description's 'linked project' phrasing aligns with that without adding new semantic detail.

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 starts with a specific verb 'List' and names the exact resource: 'protected and public storage resources for the linked project'. It also adds the important boundary 'without downloading contents', which distinguishes this from file retrieval or upload tools like micro_file_upload.

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 the tool is for listing storage metadata rather than fetching contents, which gives some usage context. However, it does not explicitly name alternatives or state when not to use this tool, leaving routing to inference rather than direct guidance.

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

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

Annotations already disclose that this is a write operation, idempotent, and non-destructive. The description goes beyond annotations by characterizing the result as a 'stable storage resource' and highlighting that access can be public or entitlement-gated, which adds useful behavioral context about the outcome and access control.

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 states the action and the key access-control choice without filler. Every phrase contributes information, and the description is easy to scan and parse.

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, an output schema, and annotations that cover safety traits, so the description does not need to explain return values. However, the description is still incomplete because the critical 'source' parameter is not explained and no routing guidance is provided. It is minimally viable for a simple upload, 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 description coverage is only 20% (only 'path' has a description), so the description must compensate. It only indirectly explains 'public' and 'entitlement' through the phrase 'public or entitlement-gated access', while leaving 'id', 'source', and 'path' poorly explained. Most critically, 'source' is ambiguous—it could be a file path, URL, or content—and the description does not clarify it.

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 ('Upload') and a specific resource ('one explicit file as a stable storage resource'), and clarifies the access modes ('public or entitlement-gated access'). The verb 'Upload' also differentiates it from the sibling tools, including 'micro_files', which presumably lists files rather than creating 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?

The description gives some usage context by specifying that exactly one file is uploaded and that access can be public or entitlement-gated. However, it does not state when to prefer this tool over alternatives, nor does it mention exclusions, prerequisites, or when not to use it. Usage guidance remains implied rather than explicit.

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

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

Annotations already establish read-only, open-world, idempotent, and non-destructive behavior. The description adds meaningful context beyond those hints by clarifying that the listing requires no authentication and no linked project, and that the snapshots are reviewed, licensed, and immutable.

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

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

A single sentence carries the verb, the resource type, key qualifiers, and access preconditions without redundancy. Every phrase earns its place and the most important action verb is front-loaded.

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

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

With no parameters, rich annotations, an output schema, and a one-sentence description that covers both data scope and access requirements, the agent has everything needed to invoke this tool correctly. No meaningful context is missing.

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

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

There are zero parameters and schema description coverage is 100%, so the schema imposes no semantic burden on the description. Per the baseline for zero-parameter tools, a 4 is appropriate; there is nothing more the description needs to clarify.

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

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

The description opens with a specific verb ('List') and a precise resource ('reviewed, licensed immutable Micro source snapshots'), making the operation unmistakable. It also states two boundary conditions, 'without authentication or a linked project,' which helps distinguish this from sibling tools that operate on authenticated or project-scoped resources.

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

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

The description gives clear context for when to use the tool: browsing curated public snapshots without needing auth or a project link. It does not explicitly name alternatives or exclusions, so it stops short of a full when-to-use/when-not-to-use guide, but the usage context is unambiguous.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the 'active' qualifier and enumerates binding categories, but it does not disclose extra behavioral details such as ordering, pagination, or external data freshness.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. Every word contributes to defining the tool's 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?

Given the zero-parameter schema, strong annotation coverage, and the presence of an output schema, the one-line description is sufficient for an agent to invoke this tool correctly. Nothing essential about the tool's behavior or scope is missing.

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

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

The input schema has zero parameters, so there are no parameter semantics for the description to clarify. The description still adds value by specifying exactly which kinds of bindings the empty call returns.

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 concrete verb, 'List', and names a specific resource: 'active repository, ref, environment, workflow, and immutable identity bindings.' This clearly identifies what the tool does and distinguishes it from mutation-style siblings like micro_github_link and micro_github_revoke.

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 intended use is implied by the verb 'List' and the unique 'bindings' resource, so an agent can infer when to call it. However, it does not explicitly state when to use this tool versus alternatives such as micro_deployments or micro_github_link, and no when-not-to-use conditions 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 annotations already covering read-only, idempotence, and destructiveness, the description adds useful context: the operation requires owner approval, writes a project file, and that file is non-secret. This goes beyond the structured hints without contradricting them.

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

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

One sentence, no filler, action first, and the essential artifact named. Every part earns its place.

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

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

The description gives the core operation and adds important context about ownership and file secrecy, but it leaves parameter meanings and sibling-tool selection unaddressed. For a five-parameter mutating tool with low schema coverage, this is adequate but clearly 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?

Only one of five parameters has a schema description, and the description does not explain how repository, ref, slug, path, or environment map to the OIDC binding or the micro.github.json file. Since schema coverage is low, the description needed to fill the semantic gap 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 uses a concrete action ('Create') on a specific resource ('OIDC binding') and names the output artifact it writes ('micro.github.json'), so an agent can tell this is the setup/authorization action rather than a listing or revocation. It does not explicitly contrast with micro_github_bindings or micro_github_revoke, but the create/write semantics make the purpose reasonably distinct 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?

There is no guidance about when to use this tool versus micro_github_bindings or micro_github_revoke, and no mention of prerequisites such as an existing project, repository, or owner-approval flow. The phrase 'owner-approved' implies a requirement but does not say how to confirm or satisfy it.

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

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

Annotations already mark the tool as destructive and read-only=false, but the description adds a specific behavioral consequence beyond the generic destructive flag: it invalidates outstanding deployment tokens. It also scopes the action to exactly one explicit binding, which helps the agent understand the blast radius.

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

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

The description is a single, front-loaded sentence that states the action, object, and side effect without filler. Every word contributes meaning, and the most important information appears first.

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

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

For a one-parameter tool with an output schema and annotations covering safety and idempotency, the description is mostly complete. It explains both the primary action and the token side effect, though it leaves the meaning of 'explicit' and the source of the binding ID implicit.

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 does connect the `binding` parameter to 'one explicit GitHub deployment binding,' but it does not explain where to get the UUID, how 'explicit' is determined, or which bindings are eligible for revocation. Some meaning is added, but the parameter documentation remains thin.

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 ('Revoke'), a precise resource ('one explicit GitHub deployment binding'), and a clear consequence ('invalidate its outstanding deployment tokens'). It is also easy to distinguish from sibling revoke tools like micro_invitation_revoke or micro_private_grant_revoke because the resource type is explicitly stated.

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 choose this tool over alternatives such as micro_github_bindings, which likely lists the bindings that could be revoked here. The description implies the action but never states a when-to-use/when-not-to-use condition or points to a prerequisite call.

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

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

Annotations only mark readOnly=false and idempotent=false, so the description's addition of 'single-use' and 'Email' gives concrete side-effect context: it sends an email and creates a one-time invitation. It does not cover auth requirements or revocation, but it adds meaningful behavior beyond the annotations.

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

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

One efficient sentence with no wasted words. The action is front-loaded and all key qualifiers fit into a single readable line.

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 5-param mutating tool with an output schema and annotations, the description plus schema covers the essential call. The only notable gap is lack of guidance about the required confirm flag and path selection, but the schema contains that information.

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

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

Despite schema coverage at 40%, the description supplies meaning for email, role, and canPromote by referring to 'Email', 'explicit role', and 'optional promotion authority'. It leaves path and confirm to the schema, which already documents their behavior, so the division is reasonable.

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 action (Email), a specific resource (one single-use project invitation), and the key qualifiers (explicit role, optional promotion authority). This distinguishes it from siblings like micro_invitations (list) and micro_invitation_revoke (revoke).

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 use when you need to send an invitation to a Micro project member, but it does not explicitly state when to prefer it over sibling tools such as micro_member_set, or when not to use it. Usage is inferable but not spelled out.

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

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

The annotations already provide destructiveHint=true, readOnlyHint=false, and idempotentHint=true, so the core safety profile is covered. The description adds meaningful scope context ('one exact', 'pending', 'before it is accepted') beyond the annotations, but it does not discuss consequences, irreversibility, or behavior when the invitation is already accepted.

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, tightly worded sentence. Every phrase adds relevant information: 'one exact' prevents bulk-revoke assumptions, 'pending project invitation' scopes the target, and 'before it is accepted' sets the state precondition. There is no redundancy or filler.

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

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

For a destructive, low-complexity tool with one required identifier plus a confirmation flag, the description covers the essential state precondition and scope. The output schema exists, so return-value documentation is not the description's responsibility. It falls slightly short of a 5 because it does not mention what happens after revocation or how failures for accepted invitations are surfaced.

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 67%, and the description does not add parameter-level semantics beyond the schema. The confirm and path parameters already have property descriptions, while invitationId is covered by format and pattern constraints. The phrase 'one exact' hints at the invitationId parameter but does not provide meaningful additional 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 clearly states a specific action ('revoke'), a precise object ('one exact pending project invitation'), and the timing constraint ('before it is accepted'). This distinguishes it from sibling tools like micro_invitation_create or micro_invitations without requiring the agent to infer the tool's purpose.

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

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

The description provides clear context for when to use this tool: it applies to a pending project invitation that has not yet been accepted. It gives an implicit when-not condition ('before it is accepted'), but it does not explicitly name alternative tools for accepted invitations or other revoke-like operations such as micro_member_remove.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive behavior. The description adds useful security-relevant context beyond those annotations by stating that acceptance tokens are deliberately not exposed and that only bounded metadata is returned. This is a concrete behavioral guarantee that helps an agent choose the tool safely.

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

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

The description is a single front-loaded sentence with no filler. It conveys the action, the resource scope, and a key behavioral constraint in under ten words, which is ideal for agent consumption.

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 one-parameter read-only listing tool with full schema coverage, an output schema, and strong annotations, this description is complete enough. The only notable gap is explicit sibling routing, which is a usage-guideline concern rather than a completeness gap.

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 fully documents the single optional path parameter with its own description and default behavior. The tool description adds no parameter-level detail, but none is needed since schema coverage is 100%.

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 ('List') and resource ('bounded invitation metadata'), and adds a meaningful qualifier: acceptance tokens are not exposed. This clearly distinguishes the read-only listing tool from sibling invitation tools like micro_invitation_create and micro_invitation_revoke.

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 intended use is implied: call this when you need to list invitations for a Micro project. However, it gives no explicit guidance about when not to use it, does not name alternatives, and leaves the agent to infer context from the word 'List' and the sibling tool 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds genuine value beyond annotations by disclosing the bounded-window behavior ('bounded recent log window'), which is a behavioral trait not expressed in the structured data. No contradiction with annotations 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 11-word sentence that front-loads the action ('Read') and packs resource, bound, and scope into minimal words. Every word earns its place; there is no filler, redundancy, or repetition of the title beyond what is useful.

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 (2 optional params, read-only, annotated as safe, with an output schema present, so return values need not be described). The description is adequate for basic invocation but leaves a meaningful gap: the 'since' parameter's semantics and the meaning of 'bounded' with respect to log size or time limits are not clarified, which an agent may need to know to use 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 only 50%: 'path' has a prose description, but 'since' has no description field—only a default of '30m' and a pattern '^\d+[mhd]$' that leave the unit semantics and meaning (time range before now) to inference. The tool description adds no parameter explanation whatsoever, so it does not compensate for the gap on the undocumented 'since' parameter.

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 ('Read'), a clear resource ('logs'), and a scope ('bounded recent log window for the linked project'). It is distinct from siblings like micro_status or micro_dev_status because 'logs' is unambiguous as a resource, though it doesn't explicitly differentiate itself from those read-adjacent 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?

Usage context is implied but not explicit: 'bounded recent log window' suggests this tool is for retrieving recent logs rather than full history, and the sibling list contains many status/monitoring tools an agent might confuse it with. However, there is no explicit statement of when to use this tool versus alternatives, no exclusions, and no mention of what to do when older logs are needed.

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

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

Annotations already declare destructiveHint true and idempotentHint true, so the mutation is disclosed. The description adds useful context by restricting to non-owner accounts and emphasizing exact matching, but it does not explain side effects or the explicit confirmation requirement beyond the schema.

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

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

A single, front-loaded sentence with no filler. Every word contributes to the meaning, and the key constraints (exact, non-owner, access revocation) are packed 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?

The core behavior is well covered by the description and annotations: destructive, idempotent, non-owner revocation. The presence of an output schema means return-value documentation is unnecessary. Some operational context, like what happens if the account does not exist or is an owner, is left out, but overall it is sufficient for a focused member-removal tool.

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

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

Schema coverage is 67%, with accountId lacking a textual description. The description fills that gap by clarifying that accountId refers to an existing non-owner member's account, adding meaning beyond the format/pattern constraints. It also relates 'linked project' to the path parameter, though less explicitly.

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 precise verb 'Revoke' and identifies the resource as 'access to the linked project' for a specific non-owner account. It clearly states the tool's scope, though it does not explicitly contrast with sibling tools like micro_member_set or micro_invitation_revoke.

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 intended use is implied by the phrasing 'revoke ... access' – an agent can infer when to call it. However, there is no explicit guidance on when not to use it or which alternative to choose, such as micro_member_set for role changes or micro_invitation_revoke for pending invitations.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds useful context about the returned content—owner, delegated members, roles, promotion authority—and that it applies to the linked project, but it does not discuss permissions, limits, or other behavioral nuances. The annotation coverage lowers the burden, so a average score is appropriate.

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 resource and immediately specifies the data categories returned. There is no fluff or repetition of schema details.

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

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

For a read-only tool with one optional parameter, full schema coverage, an output schema, and complete safety annotations, the description conveys the essential information an agent needs. The only slight gap is that 'linked project' is left implicit, but the tool's purpose and behavior are still sufficiently clear.

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

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

The only parameter, 'path', is fully documented in the schema with 100% coverage, so the description does not need to restate its meaning. It also does not add extra semantics beyond the schema, such as how 'linked project' relates to the path, so the schema-based baseline of 3 is correct.

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 names the exact resource and data returned: 'linked project's owner and delegated members, roles, and promotion authority'. This clearly distinguishes it from membership mutation or invitation 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?

The intended use case—listing project membership—is implied by the verb and object, but the description never explicitly says when to prefer this over siblings like micro_member_set or micro_ember_remove. No exclusions or alternative tool hints are provided, so guidance is only implicit.

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

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

Annotations already indicate a mutating, destructive, idempotent operation. The description adds value by explicitly saying 'replace', implying the previous role is overwritten, and by warning that viewers can never receive promotion authority. This provides a meaningful behavioral constraint beyond the structured annotations.

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

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

Two short, front-loaded sentences convey the core operation and a key constraint with no filler. Every sentence earns its place, and the most important behavioral warning comes second for emphasis.

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 rich schema, output schema, and annotations, the description covers the critical action and the main safety constraint. The main gap is that 'promotion authority' is not explicitly linked to the canPromote parameter in the description, but the schema and output schema compensate for most missing detail.

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

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

Schema description coverage is only 40%, so the description does important work by framing 'role' and clarifying that 'promotion authority' cannot apply to viewers, which maps to the canPromote field. It does not explicitly describe email or confirm, but the schema already covers those with format, const, and descriptions.

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

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

The description clearly states the action ('Add or replace') and the resource ('one existing account's project role'). It is semantically distinct from sibling tools such as micro_member_remove and micro_invitation_create, though it does not explicitly name those alternatives.

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

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

The intended use is implied: set or replace the project role for an existing member, with the added rule that viewers cannot receive promotion authority. However, the description does not explicitly state when to prefer this tool over related member/invitation tools, nor does it name alternatives or exclusions.

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

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

Annotations already communicate that the tool is read-only, idempotent, safe, and open-world. The description adds useful context by noting the catalog is public and the usage allowances are current, but it does not disclose additional behavioral details such as pagination or data freshness beyond those hints.

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-structured sentence that leads with the action and clearly states what is returned. There is no redundant wording or unnecessary 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?

For a no-parameter, read-only listing tool with a rich output schema and clear annotations, the description provides sufficient context. It states the scope (public catalog) and the nature of the data (current usage allowances), so an agent can select and invoke it correctly.

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

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

The tool has zero parameters, so the input schema is fully self-explanatory. The description does not need to describe parameters; the baseline for a parameter-less tool is appropriately high.

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 names a concrete resource ('the public Micro plan catalog and current usage allowances'), making the tool's function clear. However, it does not explicitly differentiate this from sibling tools like micro_usage, which may overlap with the 'current usage allowances' aspect.

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 purpose statement implies when to use the tool: when an agent needs plan catalog details or usage allowance information. There is no explicit guidance about when not to use it or which sibling tool to prefer, such as micro_usage or micro_billing.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive behavior; the description adds meaningful context by stating no authentication is required and that delivery indicators are bounded to 30 days. There is no contradiction with annotations.

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

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

The description is a single sentence that front-loads the verb and resource, then adds authentication and data-window constraints in a natural order. Every phrase adds information; 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?

For a zero-parameter read-only tool with a rich annotation set and an output schema, the description covers purpose, global scope, authentication requirements, and data recency constraints. No critical detail needed to invoke it correctly is missing.

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

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

There are no parameters, so there is no parameter semantics burden on the description; the schema has no properties and the 100% coverage baseline applies. The description's scope notes are sufficient in this context.

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 action ('Read'), a clear resource ('Micro-wide component state, published incidents, and bounded 30-day delivery indicators'), and an access scope ('without authentication or a linked project'). It is not a tautology, though it does not explicitly name sibling micro_status as an alternative, so it falls just short of 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?

It states a clear context for use: this is for platform-wide status when no authentication or linked project is involved. It does not explicitly explain when to prefer a sibling such as micro_status, so there is no exclusion or alternative guidance.

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

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

The description adds meaningful behavioral detail beyond the annotations: it is a build-and-upload operation that intentionally avoids project creation and slug claiming. It does not explain what 'opaque' means or what happens to the uploaded preview, but the annotations already cover the basic safety profile.

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

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

One concise sentence front-loads the core action and immediately states the key constraints. Every word earns its place, with no redundant or vague 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 single-optional-parameter tool with an output schema and informative annotations, the description is nearly complete. It clearly conveys the tool's purpose and non-effects, while the main minor gap is the lack of an explicit relationship to closely related sibling tools like micro_build or micro_deploy.

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 only parameter, 'path', has 100% schema description coverage, including its default behavior ('defaults to the server working directory'). The tool description itself adds no additional parameter guidance, so the baseline score of 3 is appropriate.

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

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

The description states a specific action ('Build and upload') and a specific resource ('an opaque preview'), and clarifies what it does not do ('without creating a project or claiming a slug'). This clearly distinguishes it from sibling tools like micro_build and micro_deploy.

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 'without creating a project or claiming a slug' gives a clear selection criterion for when to use this tool: when a preview is needed but no full project or slug should be created. However, it does not explicitly name alternative tools or say when not to use it.

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

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

Annotations already convey destructiveness (destructiveHint=true), non-read-only behavior, and idempotency. The description adds the useful clarification that token creation is not handled by this tool and must happen via a secure CLI handoff, which is beyond the annotations. It does not elaborate on consequences of revocation or the need for confirmation, but the annotations reduce the 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?

The description is two sentences with no fluff. The main action is front-loaded, and the second sentence about CLI handoff earns its place by clarifying an important boundary without adding noise.

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 revocation tool, the description combined with the input schema and annotations covers the essential behaviors: what is revoked, the single-grant scope, and the confirmation requirement. It could be more complete by pointing to micro_private_grants for discovering the grantId, but that is not strictly necessary for correct invocation.

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

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

Schema description coverage is 67%, and the schema already documents grantId, confirm, and path. The description adds no new parameter-level information; 'one exact' loosely maps to grantId but does not explain format or usage. With moderate schema coverage and no clear gaps, the description neither boosts nor harms parameter clarity.

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

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

The description clearly states the verb 'Revoke' and the resource 'one exact private-site bearer grant', which precisely identifies what the tool does. It is distinct from sibling tools like micro_private_grants (listing grants) and other revoke tools by naming the specific resource type. However, it does not explicitly name a sibling for contrast, so it falls just short of top-tier differentiation.

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

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

The description implies usage: use this tool to revoke a private-site bearer grant, and 'one exact' signals it is for a single specific grant rather than bulk operations. The line 'Token creation remains a secure CLI handoff' provides a partial exclusion by indicating that token creation is not done here. Still, it does not mention alternatives such as listing grants first via micro_private_grants or how to obtain a grantId.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful behavior beyond annotations by explicitly promising that bearer tokens are not exposed, which is valuable security-relevant context for an agent deciding whether to invoke the 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 efficient sentence that front-loads the action and object, then adds the key security qualifier. Every word earns its place and there is no redundant restatement of the tool name or title.

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, has full schema coverage for its one optional parameter, has an output schema, and annotations cover the read-only/idempotent behavior. The only mild gap is that 'bounded' is not elaborated, leaving the agent to guess what limits apply to the listing; overall the definition is adequate.

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

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

Schema description coverage is 100%, so the single optional 'path' parameter is already fully documented in the schema. The description does not add any further parameter-level meaning, but it does not need to because the schema carries the burden.

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'), names a clear resource ('bounded private-site grant metadata'), and adds a meaningful qualifier ('without exposing bearer tokens') that clarifies the tool's safety scope. It is readily distinguishable from the only close sibling, micro_private_grant_revoke, which performs a mutation.

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 what the tool does but gives no explicit guidance on when to choose it over alternatives or when not to use it. There is no mention of micro_private_grant_revoke or any other sibling, so the agent is left to infer usage purely from the name and general listing intent.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive behavior, so the bar for the description is lower. The description adds only the vague 'stable' qualifier and no additional behavioral context such as response format or path effects. It does not contradict the annotations.

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

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

The description is one short sentence that front-loads the verb and resource. It is concise with no redundant filler. It leaves 'stable' undefined, but this is a minor completeness issue rather than a conciseness problem.

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 read-only list tool with a documented schema and rich annotations, the description is mostly adequate. However, it does not explain what 'stable product resources' means, how the optional path relates to the linked project, or when to prefer this over micro_products_sync. These are notable but non-critical 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 single optional path parameter has 100% schema description coverage, including its default behavior. The tool description adds no meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description states the specific verb 'List', the resource ('product resources'), and the scope ('for the linked project'). It is clear at a basic level, though the qualifier 'stable' is somewhat opaque. It does not explicitly differentiate from sibling micro_products_sync, but the title reinforces the 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?

There is no guidance on when to use this tool versus alternatives such as micro_products_sync or micro_records. The phrase 'linked project' implies context, but no conditions, exclusions, or alternative tool pointers are provided. Given the large sibling set, this is a meaningful gap.

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

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

Annotations already declare readOnly=false, idempotent=true, destructive=false, so the core safety profile is covered. The description adds one useful behavioral guarantee—omitted remote products are not deleted—but does not disclose what acceptLiveProducts or acceptPriceChanges actually trigger. This is modest added context beyond the annotations, not a rich behavioral disclosure.

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 behavior and the important non-deletion caveat are front-loaded, making it easy for an agent to parse quickly.

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 covers return values, and annotations cover safety, but the description omits the semantics of two behavior-changing boolean flags. For a sync tool that may require accepting live products or price changes, this is a meaningful gap that could lead to incorrect invocation.

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

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

Schema description coverage is only 33%, with path documented but the two boolean parameters left unexplained. The description does not compensate: it never explains acceptLiveProducts or acceptPriceChanges, and 'declared products' only loosely hints at the sync source. The parameter meanings are largely left to inference from their names.

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

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

The description states a clear operation—'Create or update declared products'—and adds the key boundary condition 'without deleting omitted remote products,' which distinguishes it from a destructive sync. It clearly identifies the resource (declared Micro products) and differentiates it from the related micro_products sibling.

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 such as micro_products or other product-related tools. There are no prerequisites or exclusion conditions; usage is only implied by the tool name and the word 'sync.'

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

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

Beyond the annotations' destructiveHint and readOnlyHint=false, the description discloses specific consequences: immediate hiding from the runner, a 30-day slug reservation, queued protected-object cleanup, and no change to local source. These details tell an agent what to expect after calling, exactly the kind of extra value this dimension rewards. It also complements the idempotentHint=false annotation by implying a one-time permanent action.

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 entire description is one sentence that front-loads the core action and then appends four concrete consequences in a compact list. No filler or repetition of the tool title. It is appropriately sized for the destructive behavior it covers.

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

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

The description covers the main behavioral consequences (immediate hid, slug reservation, cleanup queue, local source untouched), which is sufficient for an agent to decide and invoke the tool. Return values are not described, but an output schema exists to cover them. It does not enumerate error conditions, but the confirm flag and 'exact locally linked' prerequisite are conveyed via schema and 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?

All three parameters are already fully documented in the schema (100% coverage), including the exact source for slug and the const true confirmation requirement. The tool description does not add new parameter-level semantics, only the broad context that the project is 'locally linked' and 'local source untouched,' which indirectly relates to path. At high schema coverage, the baseline of 3 is appropriate.

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

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

The opening clause 'Permanently delete the exact locally linked project' names a specific verb, resource, and scope. This distinguishes it from sibling tools like micro_project_deletions (which lists deletions) and micro_record_delete (which deletes records). The title reinforces the same resource, making the purpose unambiguous.

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

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

The description makes the use case explicit: use it to remove a linked project from the runner while preserving local source. It does not explicitly name alternatives or state when not to use it, which keeps it from a 5. The phrase 'exact locally linked' implies it is not for unlinked or directory-defined tasks, providing reasonable guidance.

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

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

Annotations already establish readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context beyond that: records are durable, scoped to the authenticated owner, include failures, and surface protected-object counts and slug release times. No contradiction with annotations exists.

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

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

The description is a single sentence that front-loads the verb and resource, then adds precise scope and included details. Every phrase earns its place, and there is no redundancy with the title or schema.

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

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

With zero parameters, strong annotations, and an output schema present, the description is nearly complete for a read-only listing tool. The only small gap is that it does not reference the natural sibling micro_project_delete or otherwise state when to consult deletion receipts, though the intended use is still reasonably inferable.

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

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

The tool has zero parameters, so there is no schema-level semantic gap for the description to compensate for. The mention of the authenticated owner account helps clarify the implicit authorization scope, but there is nothing else parameter-related to document.

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 ('durable project-deletion progress and failures'), scoped to the authenticated owner account, and adds detail about protected-object counts and slug release times. This clearly distinguishes it from the sibling action tool micro_project_delete, which likely triggers the deletion rather than listing receipts.

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

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

The description clearly implies this is the read-side tool for inspecting deletion progress and failures, and the sibling list shows micro_project_delete as the likely action counterpart. However, it never explicitly states when to use this tool versus the deletion or other project-management tools, so the guidance remains implicit rather than direct.

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

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

The annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds owner-scoped visibility beyond annotations, which is useful. However, it does not mention potential pagination, ordering, or other behavioral details; the added context is helpful but not extensive.

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 action and resource. Every word earns its place, and it does not repeat schema content or add unnecessary 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 parameterless, read-only list operation with an output schema and clear annotations, the description is complete. It correctly scopes the listing to the authenticated owner account, and nothing else is needed for an agent to invoke it correctly.

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

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

The input schema has zero parameters, so there is no parameter burden for the description to carry. The baseline of 4 applies because no parameter documentation is needed and the description correctly omits irrelevant parameter details.

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

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

The description uses a specific verb ('List') with a clear resource ('projects') and adds an important scope qualifier ('visible to the authenticated owner account'). It reads as a distinct operation separate from the numerous micro_* siblings such as micro_project_delete or micro_schedules, so an agent can identify what it does without ambiguity.

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

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

The description provides clear context: this is the tool to enumerate projects for the current owner context. It does not explicitly name alternatives or exclusions, but among the sibling list there is no other plain 'list projects' tool, so the usage context is reasonably self-evident.

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

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

Annotations indicate readOnlyHint=false, idempotentHint=false, and destructiveHint=false. The description adds useful behavior context: it fetches a snapshot, writes to a local directory, and records a base revision. It clarifies the non-read-only nature without contradicting the annotations.

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

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

The description is a single, well-structured sentence with the main action front-loaded. Every word adds meaning: 'Fetch', 'project source snapshot', 'record base revision', and 'new or empty local directory' are all relevant and there is no padding.

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

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

For a tool with 3 parameters and an output schema, the description covers the core behavior and the key precondition (empty/new directory). However, it lacks parameter mapping and usage guidance relative to siblings, so an agent may still have to inspect the schema carefully. It is minimally complete but not fully.

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 only 33%, with only 'path' described. The description mentions 'local directory' and 'project source snapshot' but never maps these to the slug, path, or directory parameters. It does not compensate for the low schema coverage, leaving agents to guess which parameter means what.

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'), resource ('project source snapshot'), and adds a distinctive outcome ('record its base revision in a new or empty local directory'). It clearly conveys what the tool does, though it does not explicitly differentiate itself from any of the many 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?

The phrase 'new or empty local directory' implies the precondition for when the tool can be used, and the purpose implies a source-fetching context. However, it gives no explicit guidance about when to use this tool over alternatives 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?

Annotations already establish readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior. The description adds valuable behavioral context beyond annotations: the ledger is 'latest', 'bounded', and 'normalized', and the tool explicitly avoids exposing payment credentials or card data. This gives an agent useful privacy and scope expectations.

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, tightly written sentence with no filler. It front-loads the action and resource, then adds the key privacy qualifier. Every part earns its place.

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

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

Given the tool's simplicity, one optional parameter, rich annotations, and an output schema, the description is largely complete for an agent to invoke correctly. The only minor gap is lack of explicit guidance on choosing among related financial inspection siblings, but that is not critical for basic invocation.

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

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

The input schema has 100% description coverage for the single optional 'path' parameter, including its default behavior. The description does not elaborate on the parameter, but since the schema already documents it fully, the baseline score of 3 applies.

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

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

The description states a specific verb ('Read'), a specific resource ('bounded normalized purchase ledger'), and a clear scope ('linked owner project'). It also adds a meaningful differentiator by noting that payment credentials and card data are not exposed, which helps distinguish it from broader billing or financial 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?

The description implies usage context by positioning this as a read-only inspection of purchase ledger data, but it does not explicitly state when to use this tool versus related siblings like micro_billing, micro_plans, or micro_usage. No exclusions or alternative routing are provided.

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