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

The description discloses the hard gates (policy thresholds triggering repository_apply_gate_failed, explicit write_permission=true otherwise repository_write_permission_required) and side effects per mode (writes nothing, commits to engine-side checkout, pushes and opens a PR). This meaningfully exceeds the destructiveHint annotation and covers failure behavior an agent must know before calling.

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?

Every sentence carries operational value: modes, outputs, gates, guidance, prerequisites. Information is front-loaded with the core verb and mode overview, and there is no filler or repetition of schema descriptions beyond what is operationally relevant.

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 11 parametersications, no output schema, and three modes, the description provides expected return values per mode, failure codes, defaults, and dependencies, all of which an agent needs to call and interpret results. The schema fills in parameter formats, so nothing critical 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 coverage is 100%, so the baseline is 3 and the description does not need to re-document parameters. It adds useful meaning by clarifying that write_permission is ignored in patch_only, that decision_plan_id and simulation_id come from simulate_repository, and by restating mode-dependent defaults already in 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?

Opening with "Materialize a simulated repository decision" provides a specific verb and resource, then enumerates the three modes and what each returns (applied=false, commit_sha, local_checkout_path, pull_request_url). It also names run_repository_fix as the chained-flow alternative, distinguishing this tool from sibling simulation/planning 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?

It explicitly advises "Use patch_only to review the diff before writing anything" and points to "run_repository_fix to chain the whole flow," plus states the prerequisite simulate_repository. It does not, however, give explicit when-to-avoid guidance for choosing local_branch versus remote_pr beyond their mode descriptions.

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

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

Annotations are sparse (all hints false), so the description carries the behavioral burden. It discloses that the tool executes synchronously to completion, is audit-logged and checkpointed, returns the updated run resource, and specifies failure modes for invalid state and unknown run_id. This is rich, transparent context 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 compact and every sentence carries essential information: the action and precondition, error cases, behavioral side effects (audit, checkpoint), return value, and sibling routing. Zero redundancy.

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

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

For a single-parameter mutation tool with no output schema, the description covers everything an agent needs: preconditions, execution semantics, error behavior, return value, and the alternative tool. Nothing 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 coverage is 100% and the schema already documents run_id as a waiting run id from create_agent_run or list_agent_runs. The description adds meaning by specifying the valid state (requires_approval) and the error behavior for invalid states (agent_run_invalid_state), helping the agent select the correct run_id.

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 ('Approve'), a specific resource ('agent run'), and the exact precondition (status requires_approval). It also clearly distinguishes itself from the sibling resume_agent_run, so an agent can tell them apart immediately.

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 explicitly states when to use the tool: for agent runs waiting on manual approval. It also names the alternative (resume_agent_run) and the condition that selects it ('for paused runs instead'). This gives clear routing guidance.

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

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

The description discloses key behaviors beyond annotations: synchronous execution, deterministic compute, nothing persisted, and no separate rate limit. It also outlines the return structure, including total, succeeded, failed, and per-item details. This aligns with readOnlyHint and idempotentHint, adding valuable context without contradiction.

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

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

The description is compact (two sentences) and well-structured: it leads with the core purpose, then usage alternatives, then behavioral specifics and return format. Every sentence contributes essential information without redundancy.

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

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

The description fully covers what the tool does, when to use it vs alternatives, execution behavior, and the complete return payload. Given the simple one-parameter schema and no output schema, this is complete and leaves no critical gaps for an agent to call it correctly.

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

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

Schema coverage is 100% for the single parameter 'items', which is described as 'Simulation requests forwarded to POST /v1/batch.' The description adds value by explaining per-item results and the envelope fields, enriching the parameter's purpose beyond the schema's minimal description.

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

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

The description clearly states the tool runs multiple simulation requests in one call and returns per-item success/failure details. It distinguishes itself from siblings by explicitly naming 'simulate' for single requests and 'submit_job' for large async runs, making its scope 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?

It provides explicit usage guidance: 'Use simulate for a single request and submit_job for very large async runs.' It also adds context that it is synchronous, deterministic, non-persisting, and has no separate rate limit, helping the agent 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 read-only/idempotent/non-destructive, and the description adds the live-connector prerequisite, the not_connected error, and the exact set of returned fields (connector_type, items, total, message, labels, discovery) — all beyond the structured metadata.

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 front-loads the purpose and then packs only high-value operational details into a short paragraph; 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 one-parameter read-only tool with no output schema, it is complete: goal, object kinds, prerequisite, failure mode, sibling alternative, and returned fields are all 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 coverage is 100% and the single parameter connector_id is already documented as coming from list_connectors. The description reinforces 'saved connector' but adds no new format, constraints, or usage semantics 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 names a specific verb ('Discover') and resource ('one saved connector'), enumerates the kind of exposed assets (files, tables, endpoints, items), and distinguishes itself from preview_browse_connector by limiting to saved connectors.

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

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

It gives an explicit precondition (connector must be live; run test_connector first), states the failure mode (not_connected), and points to the exact alternative for unsaved inline definitions (preview_browse_connector).

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 flag destructiveHint=true and idempotentHint=true, and the description adds meaningful context: the operation is audit-logged, checkpointed, and the run record is retained rather than deleted. It also states that cancellation ends the lifecycle. This adds value beyond the annotation flags 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?

Three sentences, no filler. The primary action is front-loaded, followed by conditions, alternatives, and side effects in logical order. 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 single-parameter tool with no output schema, the description covers all necessary context: when it can be used, failure modes, alternative actions, side effects, and return value. Nothing an agent needs 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?

The schema already documents run_id with 'Run id from create_agent_run or list_agent_runs' and coverage is 100%. The description only repeats the parameter name without adding new constraints or format details, so it meets the baseline for fully-covered schema 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 opens with a specific verb and resource ('Cancel an agent run by run_id') and states the terminal state ('ending its lifecycle at cancelled'). It clearly differentiates from siblings like resume_agent_run and approve_agent_run by naming them explicitly. An agent can identify the tool's purpose without inspecting other definitions.

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

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

It provides explicit eligibility criteria ('Only a paused or requires_approval run can be cancelled'), lists the exact error codes for invalid states and missing IDs, and names the alternatives ('Use resume_agent_run or approve_agent_run'). This is textbook usage guidance with no ambiguity.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false. The description adds that the job must be queued or running and that it returns the updated job record with its terminal status, plus identifies the job type as an async simulation job. No contradiction; return-value and scope details go beyond the annotation 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?

Two sentences with no waste: the first states the core action, the second adds usage guidance and return value. The main purpose 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 single-parameter destructive action with full schema coverage and annotations, the description covers when to use it, what it returns, and the job type. It doesn't specify behavior for already-terminal jobs, but that's inferable from 'queued or running' and the availability of list_jobs for checking state.

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

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

The schema has 100% coverage for job_id ('UUID of the async job'), and the description only adds 'by id,' which is redundant. No additional meaning beyond the schema, so 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 (cancel), resource (queued or running async simulation job), and method (by id). It clearly differentiates from siblings like submit_job, list_jobs, and get_job_status by naming the cancel operation and the job type.

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

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

Explicitly says 'Use this for queued or running jobs; list_jobs shows their states,' giving both the condition for use and the tool to check job state. This orients the agent within the job lifecycle without leaving inference to chance.

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 note readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds substantial behavioral context: the default text.tokenizer is deterministic and non-generative, nothing is persisted, unsupported model ids fail with model_not_supported, and the tool lacks streaming and function-calling capabilities. This goes well beyond what annotations provide.

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

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

The description is dense but front-loaded, with the core purpose in the first sentence, model routing and limitations in the second, and alternative tool guidance plus an error case in the third. Every sentence adds distinct value, and there is no repetition of schema or annotation 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?

Given the small parameter surface, rich schema documentation, and no output schema, the description covers what an agent needs: the return shape, default model behavior, provider-backed model routing, non-features, persistence behavior, and the failure mode. Nothing critical is missing for selecting and invoking the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description enriches the model parameter by explaining that text.tokenizer is a deterministic tokenizer-backed route returning a JSON tokenization summary, not a generative LLM. This directly informs parameter choice and output interpretation. The messages parameter is already well documented in 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 ('Run'), a resource (one ordered chat transcript through an Algenta model), and the returned output (assistant message plus token usage). It also distinguishes this tool from sibling tools like responses and the tokenizer-backed default model.

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

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

The description explicitly says to use responses for independent single-string utility calls, explains that provider-backed chat models are routed through list_models, and clarifies what this tool does not do (no streaming, no function/tool calling). This gives an agent clear guidance on when to select this tool over alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds meaningful behavioral context: 'Synchronous deterministic compute; nothing is persisted.' This goes beyond annotations by specifying the execution model (synchronous, deterministic) and persistence behavior. It also mentions that runs and seed are forwarded for reproducibility, which is useful. 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 three sentences, each earning its place: the first states the core function and output, the second details the winner criterion and per-entry fields, and the third gives the alternative and behavior. Information is front-loaded (main purpose first) with no filler. It is appropriately sized for the tool's complexity.

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

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

For a tool with 3 parameters, full schema coverage, and annotations that already cover safety, the description is complete. It explains the output structure (recommended_action, expected_value, probability_of_loss, delta_vs_best), the winner criterion (highest expected value), the request shape (simulate payload), and the usage alternative. There is no output schema, but the description sufficiently describes return fields. Nothing an agent needs to call 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?

Schema description coverage is 100% – all three parameters (runs, seed, scenarios) have descriptions in the schema. The description adds little new parameter meaning beyond reiterating that runs and seed are forwarded and that scenarios use the simulate payload shape, both already stated in the schema. Since the schema already documents parameters well, the baseline of 3 applies; the description doesn't compensate beyond that.

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

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

The description opens with a specific verb and resource: 'Run 2-10 named scenarios side by side and return the winner plus each scenario's deltas versus the best one.' It clearly states the output (winner and per-scenario deltas) and distinguishes itself from the sibling recommend by explicitly naming it as the alternative for ranked recommendations. This is precise and 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 explicitly tells the agent when NOT to use this tool: 'Use recommend for a ranked recommendation over actions instead.' This is a clear exclusion with a named alternative. It also implies the primary use case (comparing 2-10 scenarios) without leaving the decision to inference. The guidance is direct and actionable.

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, destructiveHint=false, but the description adds significant behavioral context: 'Creating a connection persists it and the dataset under the active API key's organization, and live sources are dialed during this call; no separate per-route rate limit applies.' This covers persistence, organization scoping, live dialing, and rate limits—valuable beyond annotation flags.

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

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

The description is front-loaded with purpose, then usage, conditions, side effects, and return format in a logical sequence. Every sentence adds value with zero redundancy. Despite covering multiple aspects, it remains tight and well-organized.

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

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

Given the tool's complexity (16 params, nested objects, no output schema), the description adequately covers the onboarding flow, return statuses, and resume condition. It doesn't enumerate all input combinations, but the schema fills that gap. Minor omissions like not explaining how to choose among data input formats are acceptable given schema coverage.

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 94%, so parameters are well-documented in the schema. The description adds semantic nuance by distinguishing canonical connector envelope from legacy compatibility fields ('Prefer connector.type plus connector.location/auth/options'), and explaining the selection resume flow. This enriches understanding beyond raw schema definitions.

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 explicitly states 'High-level data onboarding flow' and clearly differentiates from advanced tools: 'Use this instead of advanced connector/source tools for normal users.' It names the specific resource (data) and action (connect/onboard), making it unmistakable among 130+ 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?

Provides explicit when-to-use guidance ('for normal users' vs advanced tools) and conditional flow: 'If the result status is needs_selection, call connect_data again with connection_id and the chosen selection.' Names the alternative category and gives precise continuation instructions.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds valuable context beyond those: determinism, that nothing is stored, the returned fields, and the error behavior for unsupported model ids. This is robust behavioral disclosure especially with no output schema present.

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?

Every sentence earns its place: purpose, usage, behavioral guarantees, return shape, and error condition are all covered without fluff. The most important scoping information is front-loaded in the first 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?

For a simple two-parameter read-only tool, the description is fully complete. It explains what is returned, how to discover valid model ids, when to use tokenize instead, and what happens on invalid input. No essential calling information 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 already documents both parameters and their roles. The description adds minor value by naming the default model id and pointing to list_models, but most parameter meaning is already in the schema. Baseline 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Count how many tokens a supported deterministic Algenta tokenizer model produces for UTF-8 text.' It also distinguishes itself from the sibling tool tokenize by noting that tokenize is for when token strings are also needed. This makes the tool's purpose immediately clear and differentiated.

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

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

It explicitly says when to use the tool ('Use this for prompt-size checks and token budgeting') and when to use an alternative ('call tokenize when you also need the token strings'). It also instructs the agent to call list_models for supported model ids, which fully covers usage 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 are minimal (readOnlyHint=false, etc.), so the description carries the burden. It discloses that the run is persisted, audit-logged, and has a step log, events, and a replayable checkpoint. It explains the lifecycle states (completed, requires_approval, paused) and how they are triggered. No contradiction with annotations; it actually reinforces that it's a write operation.

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

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

The description is detailed but well-structured. It opens with the core purpose, then explains modes, then persistence and audit, then alternatives, and finally return value. No fluff; every sentence adds value. It's a bit long, but for a complex lifecycle tool, it's appropriate, so 4 rather than 5.

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

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

For a tool with 7 parameters, nested objects, and no output schema, the description covers the essential behavior: what it does, how modes affect execution, what gets persisted, and what is returned. It also references related tools. It's sufficient 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 schema already has 100% description coverage for all parameters, so the baseline is 3. The description adds context beyond the schema by explaining the behavioral impact of approval_mode and start_paused (e.g., parks at requires_approval or paused). It also mentions the return value includes run_id and status, which is not in schema. This enriches parameter understanding, so a 4 is warranted.

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

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

The description clearly states the tool's purpose: to create a persisted agent run lifecycle resource. It distinguishes itself from siblings by mentioning approval_mode and start_paused, and explicitly names alternative tools for different use cases. The verb 'create' and resource 'agent run' are specific and 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?

It explicitly says when to use this tool vs alternatives: 'Use product_agent_run for the simpler synchronous helper, list_agent_runs to browse, and get_agent_run_events to follow the trail.' It also explains the behavioral differences between auto and manual approval modes and start_paused, giving clear guidance on when this tool is appropriate.

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

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

Annotations only indicate readOnlyHint=false, but the description discloses critical behavioral traits: raw_key is returned exactly once and never shown again, creation is rate-limited per organization with the api_key_create_rate_limited error, and device_limit is validated against the plan ceiling. This goes well 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?

Three tight sentences with no filler. The most important warning (store raw_key immediately) is front-loaded, followed by parameter behavior, failure mode, and sibling routing.

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 creation tool with no output schema, the description sufficiently covers the return value (raw_key, one-time), error conditions, rate limiting, parameter validation, and related lifecycle tools. Nothing essential is missing.

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

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

The schema already covers all three parameters, so the baseline is 3, but the description adds meaningful semantics: expires_at is ISO-8601, device_limit caps registered devices, and excess triggers invalid_device_limit. This clarifies behavior beyond the raw schema property 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 names a specific verb and resource ('Create a new API key for the current organization') and clarifies the tool is distinct from list_api_keys and revoke_api_key. It leaves no ambiguity about what action is performed.

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 explicitly routes the agent to list_api_keys for viewing existing keys and revoke_api_key for retiring one, giving clear when-to-use guidance versus alternatives. It also flags rate limiting and a specific error code, helping the agent decide when this call is appropriate.

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

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

Annotations already indicate readOnlyHint=false and non-idempotent, but the description adds significant context: it clarifies that no charge occurs at call time, requires an owner API key, and explains the default value and error behavior. This goes well beyond the structured annotations.

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

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

The description is three sentences, each loaded with essential information: the main action, the side-effect caveat, the auth requirement, and the sibling routing. No filler words; key points are 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?

Given the tool has only one parameter, no output schema, and the return value (checkout URL) is explicitly mentioned, all necessary context for correct invocation is present. It also covers auth, default behavior, and error handling, making it complete for an agent.

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 provides a description for the 'plan' parameter (with enum and default), but the tool description adds the default explicitly ('plan defaults to developer') and the failure condition ('an unsupported plan fails with invalid_plan'). This enriches the parameter semantics beyond the schema alone.

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 (create a Stripe Checkout session), the resource (active organization), and the return value (hosted checkout URL). It also explicitly names sibling tools (get_billing_info, create_billing_portal) that serve different purposes, making the tool's unique role clear.

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

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

Provides explicit guidance: 'Use get_billing_info to check the current plan and create_billing_portal to manage an existing subscription.' This tells the agent exactly when to use this tool versus alternatives. It also notes the default plan and the error case (invalid_plan) for unsupported plans, which informs decision-making.

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 claims 'This call itself changes nothing,' which contradicts annotations readOnlyHint=false and openWorldHint=true. Creating a Stripe Billing Portal session is an external side effect, so the description is misleading about the tool's behavioral profile. This is a direct annotation contradiction.

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

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

Three compact sentences front-load the primary outcome, then cover prerequisites, failure handling, and side-effect expectations. Every sentence 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 zero-parameter operation with no output schema, the description covers the returned URL, the key failure condition, and the required prerequisite. It is nearly complete, but the contradictory 'changes nothing' claim weakens the overall context an agent can rely on.

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

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

The input schema has zero parameters and 100% schema coverage, so there is no parameter gap for the description to fill. The description still adds useful context by noting the implicit target is the 'active organization' and that no inputs are needed.

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

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

The description uses a specific verb and resource: 'Create a Stripe Billing Portal session' and states the returned value (its URL) and the end-user purpose (managing payment methods, invoices, and subscription). It also distinguishes itself from the sibling create_billing_checkout by scoping to an existing billing account.

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

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

The description explicitly states prerequisites: an owner API key and an existing billing account. It names the exact failure mode (no_billing_account), explains when the tool cannot be used (org has never checked out), and directs the agent to call create_billing_checkout first. This is explicit when-to-use and 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 indicate the tool is not read-only (readOnlyHint: false), not idempotent (idempotentHint: false), and not destructive (destructiveHint: false). The description goes beyond this by stating 'Persists the binding' at the end, which reinforces the non-transient nature. It also explains the execution_owner semantics (algenta_managed vs client_managed) and their implications for where executions run, adding value beyond annotations. The description does not contradict annotations, but could add more about failure modes or side effects beyond persistence.

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 dense but somewhat long, fitting key points into three sentences. The first sentence front-loads the primary purpose and the key parameters. The workflow guidance in the second sentence is valuable but adds length. The final note 'Persists the binding' is a bit redundant given the opening 'Save'. It is not rambling, but it could be tightened without losing 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?

The tool is a create operation with 8 parameters, nested config objects, and no output schema. The description covers the main parameters, explains the workflow, and notes the persistence. It does not specify the return format (beyond 'return it with its binding_id') or error conditions, but given the complexity and no output schema, it is fairly complete. The omission of validation details for config or scope_ref is a minor gap, but overall the description is sufficient for an agent to proceed.

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

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

Schema coverage is 100%, so the schema already documents parameter descriptions. The description adds semantic clarity by explaining the roles of scope ('decides who can use it') and execution_owner ('decides where executions run'), as well as config ('the profile's credentials and options'). This goes beyond raw field names. However, with 8 parameters and 100% schema coverage, the description's contributions are helpful but not exhaustive for every parameter (e.g., binding_name and customer_metadata are not elaborated). Given the high coverage, a 4 is warranted over baseline 3.

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

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

The description uses a specific verb 'Save' with the resource 'capability binding' and its scope. It explicitly distinguishes itself from sibling tools by naming list_capability_providers, discover_capability_binding, and test_capability_binding as related but distinct operations. This makes the purpose unmistakable.

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 an explicit workflow: first find valid pairs with list_capability_providers, then use discover_capability_binding to publish vertices and test_capability_binding to verify. It also explains when to use this tool (creating a binding) versus related tools. The prerequisites and follow-up actions are clearly stated, leaving no ambiguity.

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

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

Annotations are all false (not read-only, not idempotent, not destructive), so the description must carry behavioral info. It discloses that config is encrypted at rest, the connector starts untested, it persists under the active API key's organization, and it returns the connector with its connector_id. This is comprehensive and does not contradict annotations.

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

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

The description is three sentences, each serving a distinct purpose: main action, state and next steps, and alternative. It is front-loaded with the core function and contains no fluff, though it is slightly longer than the minimum necessary.

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 tool's purpose, behavior, expected return, and clear follow-up actions. For a creation tool with no output schema, this is complete—an agent knows exactly what to do before, during, and after the call.

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

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

Schema coverage is 100% with descriptions for all parameters. The description adds value by clarifying the config parameter (encrypted at rest, never returned), which is not fully captured in the schema. It does not redundantly restate parameter names, but it enriches the config semantics beyond the schema.

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

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

The description clearly states the action (save a connector configuration) and its purpose (for later data onboarding, health checks, and schema browsing). It also distinguishes itself from preview_test_connector, which is for trying without saving, so the tool's scope is 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 provides explicit guidance: after creating, call test_connector to verify connectivity and browse_connector to discover schema. It also names preview_test_connector as an alternative when no persistence is desired, making the decision 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?

Discloses key behavioral traits beyond annotations: asynchronous provisioning with immediate 'requested' status, automatic routing of API calls after activation, per-org uniqueness constraint, and validation failure modes. Annotations (readOnlyHint false, idempotentHint false) are consistent with a mutating, non-idempotent creation operation, and the description adds substantial operational context.

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

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

The description is dense but every clause adds value: action, asynchronous behavior, polling instruction, routing effect, auth requirement, uniqueness constraint, and validation guidance. There is no filler or redundant restatement of the tool name 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?

This is a complex, asynchronous, mutating deployment tool with no output schema and no required parameters. The description covers the full calling lifecycle: prerequisites (owner API key, valid region/provider), immediate result (requested status), follow-up (poll get_deployment), and failure handling (deployment_exists, invalid provider/region). 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%, so the schema already documents all four parameters. The description adds some context by connecting region/provider to list_deployment_regions and mentioning 'active organization,' but does not explain the nested config object structure or otherwise materially compensate beyond the schema. 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?

States a specific verb and resource: 'Request a new isolated engine deployment for the active organization on the chosen provider and region.' It clearly differentiates from sibling tools by explicitly referencing get_deployment, delete_deployment, and list_deployment_regions, so an agent can distinguish it from related deployment operations.

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

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

Provides explicit when-to-use guidance: only one active/in-progress deployment per org, requires owner API key, unknown provider/region pairs fail validation, and deployment_exists means delete_deployment first. It also tells the agent to poll get_deployment until status is active, making the usage workflow 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?

The annotations indicate readOnlyHint=false (so a write is expected), destructiveHint=false (not destructive), idempotentHint=false, and openWorldHint=true. The description adds significant behavioral context beyond those annotations: it states the operation is 'stored' and 'immutable', that it 'persists the plan revision', that snapshot_id is resolved from the bundle when omitted, and that the model optionally picks the planner model. This goes beyond the bare annotations and explains the persistence and lifecycle behavior. It does not contradict annotations, and while it doesn't detail error conditions, it provides meaningful context for a mutation 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 efficiently written, with the core purpose stated first, then the bundle resolution detail, the pipeline context, and the alternative. It is two dense sentences but not overly long. Every sentence adds value: the first introduces the action and return, the second explains the LLM stage and the chaining alternative. No fluff, though the phrasing 'model optionally picks the planner model' is slightly awkward. Overall it's well-structured and front-loaded.

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

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

Given that the tool has an output schema? No, it has no output schema, so the description must explain the return value, which it does (decision_plan_id plus patch diff). The complexity is moderate (4 parameters, with an optional model and snapshot resolution). The description covers the relationship to the pipeline (simulate and apply), the input from triage, and the persistence behavior. It lacks details about error conditions or exact format of the patch diff, but it provides enough for an agent to know what to expect and how this fits into the workflow.

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

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

The schema has 100% coverage with descriptions for all parameters, so the baseline is 3. The description adds extra semantic meaning beyond that: it explains that snapshot_id is resolved from the bundle when omitted (which is already in the schema but reinforces it), and it clarifies the role of model as an optional override and the only LLM-touching stage. It also explains the purpose of workspace_evidence_bundle_ref as feeding from triage_repository. This adds context that helps an agent understand dependencies and optionality beyond the schema's dry 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 states a specific action ('Create one stored, immutable repository DecisionPlan revision'), a clear resource (DecisionPlan), and the input (triage workspace evidence bundle), while also mentioning the primary return value (decision_plan_id plus patch diff). It distinguishes itself from siblings by mentioning that it is the only LLM-touching stage and that simulate_repository and apply_repository consume its output, and it explicitly points to run_repository_pipeline as the chaining alternative. This is far beyond a tautology and gives the agent a concrete handle on what this tool achieves.

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

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

The description provides explicit guidance on when to use this tool versus alternatives: it is the only LLM-touching stage, and it says to use run_repository_pipeline to chain the entire pipeline in one call. It also implies that if you need to go further in the pipeline, you chain simulate_repository and apply_repository after, making the context of use clear. There are no explicit exclusions, but the alternative is named and the condition for choosing it is 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 idempotentHint=true, destructiveHint=false, openWorldHint=true, and readOnlyHint=false. The description adds valuable context: it reads the repository and persists snapshot, symbol, and dependency graph artifacts, while never writing to the repository. It also discloses the idempotent reuse with status='existing'. This exceeds what annotations alone convey, providing the agent with a clear understanding of side effects and safety. 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 paragraph with multiple sentences, each serving a purpose: stating the core function, idempotent behavior, downstream usage, side effects, and return fields. It is front-loaded with the primary action. It's slightly verbose but not wasteful, and the structure is logical. It earns a 4 for being informative without excessive fluff.

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

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

The tool is moderately complex with 6 parameters and no output schema. The description covers the key contextual elements: what the snapshot is, how it's used downstream, the idempotent reuse behavior, side effects (persisting artifacts, not writing to the repo), and the return fields (snapshot_id, resolved_revision, content_hash, file_count, language_counts, artifact refs). It lacks details like auth requirements or potential error conditions, but given the annotations and schema, it is adequately complete for an agent to call it correctly.

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

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

Schema description coverage is 100%, so all six parameters are documented in the schema. The description adds minimal parameter-specific meaning beyond the schema, only clarifying that repository_id comes from list_connectors. It does mention the content-hashed nature of the snapshot, which relates to the output, but not to individual parameters. Given full schema coverage, a baseline of 3 is appropriate; the description doesn't significantly augment parameter understanding.

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

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

The description clearly states the tool creates or reuses an immutable content-hashed snapshot of a repository connector, and it distinguishes this from related tools like get_repository_snapshot by emphasizing the create/reuse behavior and its role as input to triage_repository and query_repository_graph. The reference to list_connectors for finding the id adds clarity. It could be more explicit about the distinction from get_repository_snapshot, but the purpose is clear.

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

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

The description explains when to use the tool: as the entry point for snapshotting before triage/query, and that re-running with identical inputs returns the existing snapshot (idempotent reuse). It implicitly suggests that once you have a snapshot_id, you might use get_repository_snapshot, but it doesn't explicitly state that alternative. The guidance is clear on the idempotent behavior and the downstream dependency, which is sufficient for an agent.

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

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

Annotations already declare destructiveHint and idempotentHint, and the description adds the consequence that deleting removes the saved definition (unlike update_connector) and specifies the success response shape: 'connector_id with deleted: true.' This goes beyond the structured fields 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 short sentences front-load the action, then provide the relevant alternative and the return value. Every sentence earns its place; there is no redundant filler.

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

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

For a one-parameter destructive delete with no output schema, the description covers what is deleted, which sibling covers the alternative use case, and what the caller gets back. Nothing essential is missing 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?

The schema only names connector_id as a required string with minLength 1. The description adds the operational meaning: it is the id of the saved connector being deleted. For a single obvious parameter this is enough, though no format or prefix guidance is given.

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 precise verb and object: 'Delete one saved connector by id.' It also names the sibling update_connector, so an agent can distinguish deletion from configuration updates without inspecting other 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?

It explicitly routes the 'change config' use case to update_connector and frames deletion as the operation that removes the saved connector. This gives clear selection criteria relative to the closely related sibling.

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 set destructiveHint=true, but the description adds the crucial detail 'Deletion is permanent' and clarifies that a deletion confirmation is returned for the decision_id. 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 tightly packed sentences with no waste. The action verb is front-loaded, followed by a warning and a return-value note. Every phrase 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 single-parameter deletion tool, the description covers the action, the permanence, the prerequisite review step, and the return value. Combined with full schema coverage and accurate annotations, 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?

Schema coverage is 100% and the parameter is already described as 'Decision ID to delete.' The description adds minimal semantic value, just reiterating the id-based targeting with 'by id.' 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?

States the specific verb 'delete' and resource 'decision-memory record' with id-based targeting. This clearly distinguishes it from siblings like list_decisions and get_decision.

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

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

Provides a concrete guideline to review with list_decisions before deleting, which implies when this tool is appropriate. It does not explicitly name alternatives or when-not-to-use scenarios, but the permanent-deletion warning effectively discourages careless use.

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

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

Annotations already provide destructiveHint=true and idempotentHint=true, and the description adds meaningful context: the operation is asynchronous, returns status 'deprovisioning', and errors with already_deprovisioned. This goes beyond the structured 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?

Three tightly packed sentences: purpose, usage sequencing, and behavioral result. No filler, and the most important information is front-loaded.

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

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

For a single-parameter destructive async operation, the description covers purpose, sequencing, return status, and a key failure mode. It could mention how to observe completion or handle a missing deployment, but the annotation set and simple schema make this adequate.

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

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

Schema description coverage is 0%, so the description must compensate for the deployment_id parameter. It only says 'by id' and echoes deployment_id without explaining the ID format, where to obtain it, or prerequisites such as the deployment existing. The parameter name and schema carry most of the meaning.

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

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

States a specific verb and resource: 'Request deprovisioning for one deployment by id.' It also distinguishes itself from create_deployment by explaining the lifecycle relationship, so an agent can tell which operation to select.

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

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

Gives explicit context: use before create_deployment when a deployment already exists, and warns that already-deprovisioned deployments fail. It does not name an alternative like get_deployment for checking status, so it stops just short of full when-to-use/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?

Description contradicts annotations: idempotentHint: true while description says 'An unknown trigger_id fails with not_found', implying repeated deletes of the same id fail (since the id becomes unknown). This is not idempotent behavior. Otherwise the description is transparent about immediacy, permanence, and return value, but the contradiction forces a score of 1.

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

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

Three sentences, front-loaded with the action, then consequences, alternative, error handling, and return. No wasted words; every sentence adds value.

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

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

For a simple one-parameter tool with no output schema, the description covers action, parameter sourcing, consequences, alternative, error case, and return format. Nothing an agent needs to call 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?

Schema already describes trigger_id as 'Trigger ID to delete' (100% coverage). Description adds how to obtain it (list_triggers) and error semantics (not_found), exceeding the baseline for high coverage.

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

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

Description clearly states 'Delete one trigger by trigger_id' – a specific verb and resource. It also names the alternative (pause_trigger) and the source for IDs (list_triggers), fully distinguishing it from 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?

Explicitly provides when to use (delete permanently) vs. alternative (use pause_trigger for temporary stop). Also tells the agent how to obtain the parameter (find ids with list_triggers) and what error to expect (not_found).

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 concrete behavioral details beyond annotations: the skill immediately disappears from the capability catalog, is no longer routable or executable, and deletion is permanent. It also states the return shape, all consistent with the destructiveHint and idempotentHint annotations.

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

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

Three focused sentences deliver the mechanism, immediate effects, permanence, return value, and usage restriction with no filler. The most important caveat ('permanent removal') is front-loaded and repeated clearly.

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

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

For a one-parameter tool with no output schema, the description is complete: it gives the required identifier source, the behavioral outcome, the return value, and the usage boundary. An agent has everything needed to decide and execute 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 schema already fully documents the single binding_id parameter, so the baseline is 3. The description adds useful sourcing guidance by telling the agent to find binding ids via list_skills or list_capability_bindings, which goes 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 action (disable one skill) and the exact mechanism (deleting its capability binding), and clarifies the permanent consequence. It clearly differentiates from adjacent tools like enable_skill and list_capability_bindings.

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 explicitly scopes usage to permanent removal only and mentions that re-enabling later requires a fresh enable_skill call, which names the relevant alternative. This gives an agent clear guidance on when to invoke this tool versus others.

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 destructive and idempotent, but the description adds crucial details: the conditional deletion of the backing connection, the connection_deleted flag, permission requirements, error cases, and immediate execution. No contradictions with annotations.

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

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

Three sentences, no waste. The main purpose is front-loaded, followed by side effects, errors, and usage hint. Every sentence adds essential 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?

Fully complete for a destructive action with side effects. It covers purpose, side effects, permission, errors, usage guidance, and return fields (dataset_id, status, connection_deleted) despite having no 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?

Schema coverage is 100% and already describes dataset_id. The description adds minor value by specifying where to obtain the ID (from connect_data or list_data), but this is a small enhancement over the schema baseline.

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

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

States a specific action (delete) on a specific resource (saved dataset) and clarifies the additional side effect on the backing connection. This distinguishes it from sibling delete tools like delete_connector or revoke_api_key.

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

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

Provides clear context on when to use (to delete a dataset) and offers a prerequisite hint to confirm with list_data first. It does not explicitly name alternatives, but the scope is unambiguous given the sibling 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?

The description transparently discloses the side-effect behavior for saved bindings ('this publishes or refreshes its capabilities in the catalog'), which aligns with readOnlyHint=false and idempotentHint=false. It also clarifies that inline definitions are only previewed ('never saved'), adding behavioral nuance beyond the annotations. No contradiction with annotations was found.

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

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

Three sentences, each earning its place: the first states the core outcome, the second contrasts the two usage modes, and the third gives concrete lifecycle context. The most important scoping information is front-loaded, and no filler or redundant wording exists.

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 purpose, modes, and workflow but leaves a key gap: it never specifies what constitutes a valid 'full inline definition' (e.g., which of the seven inline fields are required together). With zero required parameters in the schema, an agent could reasonably call the tool with neither binding_id nor an inline definition. The schema's per-field descriptions mitigate but do not close this ambiguity, and there is no output schema to describe the returned catalog entry structure.

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%, providing baseline value. The description goes further by grouping parameters conceptually: binding_id for saved discovery versus the other parameters forming 'a full inline definition' for preview. This mode-level semantics helps an agent understand how to choose among the eight optional parameters without repeating the schema text.

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

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

The description states a specific verb and resource: 'Discover the capabilities one binding exposes and return them as catalog entries.' It clearly differentiates the two modes (saved binding via binding_id vs inline preview) and references sibling tools (create_capability_binding, list_capabilities), making its role in the capability lifecycle unmistakable.

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

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

The description provides explicit sequencing guidance: 'Call this after create_capability_binding, then browse the result with list_capabilities.' It also explains when to use binding_id versus an inline definitioniciously. However, it does not explicitly distinguish this from test_capability_binding or state when not to use it, so the guidance falls short of a full when/when-not specification.

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 readOnlyHint, openWorldHint, and destructiveHint, and the description adds substantial behavioral context beyond them: deterministic outputs for the default model, provider routing, the fact that nothing is stored, the exact per-item return shape, total token usage, and the specific model_not_supported error. This is rich, non-redundant 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 information-dense but every sentence earns its place: primary behavior, model behavior, sibling routing, read-only safety, return format, and error semantics. The core action and key distinction are front-loaded, and nothing is padded or redundant with the schema.

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

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

For a 3-parameter tool with no output schema, the description covers everything an agent needs to invoke it correctly: input shape, model selection behavior, return item structure, token usage reporting, error behavior, and read-only semantics. The sibling navigation is also explicitly handled. Nothing material 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 coverage is 100%, so the baseline is 3, but the description adds meaningful semantic value for the model parameter: it names the default model, explains that it is deterministic and lexical, and clarifies that provider-backed models are advertised by list_models. It also clarifies the input cardinality for the input parameter. These additions raise it above baseline.

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

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

The description states a precise action and resource: 'Generate one embedding vector per input string.' It also distinguishes between the default deterministic hash model and provider-backed models, and explicitly routes the agent to sibling tools (embedding_similarity, rerank) for different operations, making it unmistakable what this tool does.

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

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

The description explicitly tells the agent when to use this tool versus related alternatives: 'Use embedding_similarity to score two vectors or rerank to order documents against a query vector.' It also clarifies the model source (list_models) and the failure mode for unsupported models, leaving no ambiguity about invocation 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?

Beyond annotations (readOnlyHint, idempotentHint), the description discloses deterministic behavior, the exact failure condition (invalid_embedding_dimensions on unequal lengths), and the precise return fields. This is substantive behavioral context that an agent needs to handle errors and interpret results.

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

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

Four sentences, each earning its place: purpose, key exclusion, constraint/failure, and read-only/return behavior. Information is front-loaded and there is no filler or repetition of schema 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?

Despite lacking an output schema, the description names all returned fields (resolved model id, similarity_metric, score, shared vector dimension) and the failure mode. Given the simple parameter set and strong annotations, nothing an agent needs to call 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 coverage is 100%, so the baseline is 3. The description adds real value by specifying that left and right must have equal length or the call fails, and by noting that model selects the metric (reinforcing the schema's own note). This failure-mode detail is not in the schema, so the score is above baseline.

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

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

States a specific verb ('Score') and resource ('similarity between two caller-supplied embedding vectors') and explicitly differentiates itself from embeddings generation by naming the embeddings tool as the prerequisite. This makes it unmistakable among the large sibling set.

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

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

Provides clear usage context by stating that embeddings must be produced first and that this tool does not generate them. It stops short of naming alternative similarity/ranking tools or giving explicit 'when not to use' instructions beyond the embeddings prerequisite, but the guidance is unambiguous for the core workflow.

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

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

Annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=false) indicate this is a mutating, non-idempotent operation, but the description goes further by explicitly stating that it 'Persists a new binding', which implies state change and non-idempotency. It also reveals the routing behavior through route_capabilities and scope under the caller's user scope—valuable context not covered by annotations.

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

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

The description is three sentences, front-loading the primary outcome, and each sentence serves a purpose: first states action and result, second describes the internal mechanics, third provides lifecycle guidance. No fluff or repetition.

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

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

For a mutation tool with no output schema and no annotations covering side effects, the description adequately covers the persistence and removal. It doesn't explicitly state what happens if the skill already exists (e.g., overwrite vs. duplicate), but given the non-idempotentHint and the presence of list_skills, this is a minor gap. The description is complete enough for an agent to call 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 coverage is 100%, so all six parameters are documented in the schema itself. The description adds no new parameter-specific semantics beyond what the schema provides (e.g., it doesn't explain how tags or artifact_affinities are used in routing). Given full schema coverage, baseline 3 is appropriate; the description's mention of 'instruction text' aligns with the 'instruction' parameter but doesn't add extra.

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 ('Enable') and direct resource ('one prompt skill') as a 'first-class capability binding', with a concrete outcome: the skill's instruction text becomes an instruction_only capability selectable by route_capabilities. It also names two siblings (disable_skill, list_skills) for lifecycle management, distinguishing this from them.

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

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

The description gives clear context: when you want to enable a skill as a binding, and explicitly says to use disable_skill to remove it and list_skills to see what's enabled. It lacks explicit 'when not to use' or mention of alternatives for creating other binding types (e.g., create_capability_binding), but the sibling pair is clearly named.

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

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

The description discloses important behavioral traits beyond the annotations: it returns a pending plan instead of executing when approval is required, it refuses client_managed routes, and it notes that approval and final execution are separate credentialed HTTP operations not exposed as tools. These details materially shape agent 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 packs the core action, return type, routing constraint, approval behavior, and alternative tool recommendation into three focused sentences. No sentence is wasted, and the primary action 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?

The tool is complex, has no output schema, and accepts nested objects, but the description covers the critical operational paths: execution, client_managed exclusion, approval-required behavior, and routing prerequisites. It stops short of describing the execution receipt's structure or possible failure modes, which is a minor gap given the open-world output.

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 input schema already documents capability_id, input, binding_id, and request_id. The description adds only modest value by noting capability_id originates from route_capabilities or list_capabilities, which is helpful but not a substantial enhancement over 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 action (execute) on a specific resource (an algenta_managed capability by capability id) and explicitly defines the return value (execution receipt). It also distinguishes itself from routing tools by clarifying that it executes known or routed capabilities, not routing itself.

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

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

It gives explicit when-to-use guidance: only for routed or known algenta_managed capabilities. It further states exclusions (client_managed routes will not run here), the approval-required alternative behavior, and prioritizes route_capabilities when the right capability is unknown.

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

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

Annotations already declare the tool non-readOnly, non-destructive, and idempotent. The description adds meaningful behavioral context by mentioning the external webhook delivery, persistence of the execution receipt, and the exact receipt fields returned. It does not contradict the annotations, and it provides enough side-effect context for an agent to understand the operation.

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

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

The description is two well-structured sentences: purpose first, alternative routing second, and return details in a compact list. There is no filler or redundant repetition of schema property names. It earns its place with high information density.

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

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

With no output schema, the description usefully enumerates the receipt fields, compensating for that gap. Parameters are fully documented in the schema, and annotations cover idempotency and safety expectations. It does not describe error conditions, retry behavior, or webhook authentication, but those are not essential for selecting and invoking the tool correctly.

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

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

Schema description coverage is 100%, so every parameter is already documented in the input schema. The description adds little to the parameter-level explanation beyond labeling the action as dispatching to a webhook and describing the receipt fields. This meets the baseline for schema-complete parameters but does not elevate 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 opens with a specific verb and object: 'Dispatch a logged decision to an external webhook and persist the execution receipt.' This clearly distinguishes the tool from record_outcome and other siblings by naming the alternate usage. The return value list further specifies what the tool accomplishes.

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 explicitly states a when-not condition: 'Use record_outcome instead when reporting a result rather than dispatching an action.' This gives an agent a clear decision rule for choosing between closely related tools. The overall purpose also implies when to use this tool: when a logged decision needs to be dispatched and a receipt persisted.

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 read-only, idempotent, and non-destructive behavior; the description adds valuable behavioral context: errors (module_not_registered, function_not_registered, invalid_arguments), synchronous execution, and the fact that nothing is persisted. This exceeds what the annotations convey.

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

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

Three sentences, with the core purpose front-loaded, followed by prerequisite guidance and behavioral caveats. Every sentence earns its place and there is no redundant restatement of the schema.

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

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

Given no output schema, the description names the return fields, explains the discovery prerequisite, covers likely error conditions, and clarifies side effects. An agent has what it needs to decide when and how to call this tool.

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

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

Schema description coverage is 100%, so the parameters are already documented; the description adds the clarification that args are positional and that request_id is echoed in the response, but it does not need to compensate for gaps. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('execute') and resource ('one public function from an Algenta runtime library') and states the exact return values. This clearly distinguishes it from the sibling list_runtime_libraries, which only enumerates available libraries.

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 explicitly instructs the agent to call list_runtime_libraries first to discover valid module and function names, and it describes the failure modes for unknown or mismatched inputs. This is concrete when-to-use guidance, including the prerequisite step and 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?

Discloses the manual behavior, the bypassing of threshold checks, and the returned fields. It also adds context beyond annotations by clarifying that this is a forced/manual evaluation and does not delete the trigger. Slight ambiguity remains because the description says runs 'regardless of whether the threshold is currently met' while the force parameter defaults to false, but this is not a contradiction with 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?

Three dense sentences with no filler. The primary behavior, use case, alternative, and return value are all front-loaded and each sentence earns its place.

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

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

Despite lacking an output schema, the description explicitly enumerates all return fields. It also covers when to use the tool and how it relates to pause_trigger, making it complete enough for an agent to invoke 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 coverage is 100%, so the parameters are already fully documented. The description adds operational context but does not add meaning beyond the schema's own parameter descriptions, 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?

States a specific verb ('fire'), a concrete resource ('trigger'), and the core effect: evaluate the condition and run the simulation template. It clearly differentiates from sibling tools like pause_trigger and register_trigger by describing what this action does.

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

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

Explicitly explains when to use it: 'testing triggers or forcing an immediate evaluation.' It also names the relevant alternative, pause_trigger, and explains the difference: pausing stops automatic firing without deleting the trigger.

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, and the description reinforces read-only behavior. It adds value beyond annotations by specifying the exact error for an unknown run_id (agent_run_not_found) and enumerating the returned fields, giving the agent a fuller picture of the call's behavior.

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

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

The description is two sentences, front-loaded with the core action and returned fields, then usage guidance and error behavior. No redundant wording 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?

With no output schema, the description compensates by listing the returned fields and the error condition. For a single-parameter, read-only tool, this is complete guidance for correct invocation and interpretation.

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 schema already explains run_id as the id returned by create_agent_run or list_agent_runs. The description adds no new parameter semantics beyond that, 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 clearly states the tool fetches one persisted agent run by run_id and lists the exact fields returned (status, task, selected_tool, steps, result, tools_used, snapshot ids). It also names sibling tools that serve different purposes, making it easy to distinguish from list_agent_runs, get_agent_run_events, and get_agent_run_checkpoints.

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

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

The description explicitly says to use list_agent_runs to find run ids, get_agent_run_events for the event trail, and get_agent_run_checkpoints for replay checkpoints. This provides clear when-to-use guidance and routes the agent away from this tool for those needs.

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

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

Annotations mark read-only/idempotent, but the description adds meaningful context: checkpoints are persisted deterministic snapshots created at lifecycle transitions, and unknown run_ids fail with agent_run_not_found. This explains behavior beyond the annotation flags.

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

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

Three focused sentences: purpose, sibling routing, then read-only/error/return behavior. Front-loaded and every clause adds value.

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

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

For a one-parameter read-only tool, the description covers scope, error behavior, and return object at a high level. No output schema exists, but the description tells the agent what to expect and when to use it; annotations cover safety.

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 already covers the sole run_id parameter at 100% with guidance on where to obtain it. Description adds only the error condition for invalid IDs, so it does not need to compensate; 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?

States a specific verb and resource ('List persisted checkpoints of one agent run') and explicitly contrasts with sibling query_agent_run_checkpoints. An agent can identify exactly what this returns and how it differs.

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?

Directs agents to query_agent_run_checkpoints for cross-run searches, making the single-run vs across-run choice explicit. Also notes unknown run_id failure condition, adding operational guidance.

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

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

Annotations already declare readOnlyHint and destructiveHint, and the description adds further behavioral detail: append-only semantics, event ordering, specific failure behavior, and the return summary. 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?

Three dense sentences with no filler. The core purpose is front-loaded, and each clause adds value: event types, ordering, alternative tool, read-only status, failure behavior, and return shape.

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 two-parameter read tool with strong annotations, the description provides everything needed: event domain, ordering, relation to the sibling tool, failure mode, and return summary. The lack of an output schema is mitigated by the explicit return 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?

Schema description coverage is 100%, and the schema already explains run_id provenance and limit defaults. The description adds error behavior tied to run_id, but no new parameter format or semantics, so the baseline of 3 is appropriate.

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

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

The description names a specific verb and resource: 'Fetch the append-only event stream of one agent run'. It enumerates the event types, states ordering, and explicitly distinguishes the tool from get_agent_run_mission_events, making selection 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 explicitly routes to the sibling tool for the canonical mission-event projection, which clarifies when not to use this tool. It also states the read-only nature and the failure mode for unknown run_id.

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 bar is lower. The description adds useful behavioral context: it is read-only, an unknown run_id fails with agent_run_not_found, and it returns the run's canonical mission-event records. This exceeds what the annotations alone provide, though it does not detail response ordering or field-level behavior.

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

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

The description is three concise sentences with no filler. The core purpose is front-loaded, followed by differentiation from siblings and then behavioral/error details, making it easy to scan.

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

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

For a two-parameter read-only tool with complete schema coverage and safe annotations, the description covers selection, behavior, error condition, and return intent. No output schema exists, and the description adequately states that the tool returns canonical mission-event records without needing to enumerate response fields.

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 run_id and limit well. The description adds the contextual note that run_id selects 'one agent run' and mentions the error for an unknown run_id, but it does not add substantial meaning beyond the schema's own parameter 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 states a specific verb ('Fetch') and resource ('canonical mission-event records of one agent run'), and clarifies it as 'the typed, indexed projection of its lifecycle used for audit and replay.' It explicitly distinguishes itself from get_agent_run_events and query_agent_run_mission_events, so an agent can select it unambiguously.

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

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

The description gives explicit routing guidance: use get_agent_run_events for the raw append-only stream and query_agent_run_mission_events to search mission events across runs. This clearly states the condition for choosing this tool versus the relevant alternatives.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds the specific error condition 'agent_run_not_found' for unknown run_id, which is beyond what annotations provide. It also clarifies the return type (telemetry batches), though that's somewhat redundant with the purpose. The added error detail elevates it above baseline.

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

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

Three sentences with no filler. The main action and scope are front-loaded, followed by a sibling reference, an error note, and a return statement. Every sentence adds value and the structure is efficient.

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

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

Given the simple read-only nature, two well-documented parameters, and the annotations covering safety, the description is complete. It includes the error behavior and states the return type. No critical information is missing for an agent to correctly invoke this tool.

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

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

Schema description coverage is 100%, with both 'run_id' and 'limit' fully described in the schema. The description does not add additional parameter-level semantics, which is acceptable given the schema's completeness. Baseline of 3 is appropriate.

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

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

The description clearly states the specific verb 'Fetch' and resource 'runtime telemetry batches recorded for one agent run', and explicitly differentiates from sibling query_agent_run_telemetry which searches across runs. An agent can immediately distinguish this tool from its siblings without needing to inspect 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?

It explicitly directs when to use the alternative query_agent_run_telemetry for cross-run searches, and also notes the error case for unknown run_id. This gives clear contextual guidance on when this tool is appropriate versus when to choose another.

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 fully covered. The description adds useful context about the lookback window and returned metrics, but does not describe response format, pagination, or failure behavior. This is helpful but not rich beyond annotations.

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

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

Three short sentences front-load the purpose, then list metrics, parameter details, and the alternative tool. Every sentence earns its place; the only redundancy is 'Read-only,' which mirrors the annotation but does not bloat the description.

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

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

For a one-optional-parameter read-only analytics call with no output schema, the description names all returned metrics, documents the window default and range, and gives an alternative. An agent can invoke it and interpret the response without needing further information.

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

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

Schema coverage is 100% with a default, so the baseline is 3. The description adds the explicit range 1-365 and confirms that days controls the window, going beyond the schema's terse 'Lookback window in days'.

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

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

The description opens with a specific verb and resource ('Get aggregate usage analytics over the organization's simulation runs'), enumerates the returned metrics, and explicitly frames this as aggregates versus individual runs. This makes it clearly distinguishable from list_runs and other 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?

It explicitly says 'Use list_runs for individual runs instead of aggregates,' giving a direct alternative and the condition that selects it. The aggregate-versus-individual contrast tells the agent when this tool is appropriate versus its closest sibling.

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 readOnly, idempotent, and non-destructive traits, and the description reinforces those while adding beyond them: artifacts are immutable and tamper-evident, admin API keys are required, workspace-scoped keys see only their own artifacts, and the response shape includes entries, total, page, limit, and pages. This is useful behavioral context that annotations alone do not provide.

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

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

The description is immediately informative: the first sentence states the resource, pagination, and filter nature, and the remaining sentences cover the key behavioral distinctions and auth requirements. Every sentence carries purposeful information, with no repetition or filler beyond reinforcing the read-only trait already in annotations.

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

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

For an 11-parameter read-only query tool with no output schema, the description provides the essential operating context: pagination defaults, filter semantics, artifact immutability, auth requirements, scoping behavior, and return fields. The parameter-level details are already fully documented in the input schema, so nothing critical is missing 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 coverage is 100%, so the baseline is 3. The description adds value by stating the filters are exact-match and by highlighting content_hash as a way to pinpoint one artifact, which is not explicit in the schema. It also summarizes pagination defaults already in the schema, so the added semantic load is moderate but meaningful.

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 ('Query'), a concrete resource ('the organization's immutable Parquet audit-log artifacts'), and states its core function clearly. It also explicitly differentiates from the sibling 'get_audit_logs' by calling out the live audit-event table, so an agent can distinguish the two tools without inspecting 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?

It explicitly says to use 'get_audit_logs' for the live audit-event table, framing the current tool as the tamper-evident artifact counterpart. It also states the admin-key requirement and workspace-scoped visibility, giving clear guidance on when this tool is appropriate and what privileges 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?

Beyond the read-only/idempotent/non-destructive annotations, the description adds behavioral details: newest-first ordering, pagination defaults, honest empty page behavior, admin key requirement, and return shape (entries, total, page, limit, pages). This substantially enriches the agent's understanding.

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 information-dense yet efficient, covering purpose, pagination, filters, empty behavior, auth, alternative tool, and return fields in a few sentences. It is front-loaded with the main purpose and avoids redundancy.

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

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

For a tool with 10 parameters and no output schema, the description provides a complete picture: purpose, behavioral traits, auth prerequisite, pagination, filters, return format, and differentiation from a sibling. 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?

Schema coverage is 100% so the baseline is 3. The description adds value by framing certain filters (policy_snapshot_id, schema_snapshot_id, manifest_version, request_hash) as a way to trace one execution, providing context beyond the individual parameter descriptions. It also states pagination defaults which reinforce the schema, but does not fully compensate for the lack of enums or value examples.

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

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

The description clearly states the tool queries the organization's audit-event log with specific verb and resource, and distinguishes it from the sibling get_audit_log_artifacts. It also mentions pagination and exact-match filters, 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?

It explicitly directs users to get_audit_log_artifacts for the immutable Parquet artifact copy, and suggests filtering by specific fields to trace an execution. It also notes the admin API key requirement, giving clear when-to-use and 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful context beyond annotations: it is 'not separately rate-limited' and scoped to the active organization. It also states the returned fields, which is helpful since there is no output schema.

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

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

Three short sentences, each carrying distinct value: what it returns, its safety and rate-limit profile, and which sibling tools to use for mutations. It is front-loaded and contains 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 no-parameter read-only tool, the description fully covers purpose, behavior, alternatives, and return fields. Nothing essential is missing for an agent to 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 and the input schema is empty, so the description correctly avoids inventing parameters. The mention of 'active organization' clarifies the implicit execution scope, adding meaning beyond the bare schema.

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

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

The description clearly states the operation ('Get'), the resource ('current billing plan and subscription info'), and the scope ('for the active organization'). It also distinguishes itself from the related billing mutation tools by name, so an agent can identify it without opening schemas.

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

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

Explicitly says it is read-only and non-destructive, and directs the agent to create_billing_checkout or create_billing_portal for any changes. This gives clear when-to-use versus when-not-to-use guidance and names the exact alternatives.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds a useful error condition ('unknown id fails with not_found') and the conditional include_instruction behavior beyond what annotations provide.

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

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

Three tight sentences, front-loaded with the primary purpose and returned fields. No filler; each sentence adds a distinct piece of information.

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

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

For a simple single-entry fetch tool with rich annotations, the description covers id source, return contents, optional instruction text, and error behavior. The lack of an output schema makes exact response-shape details unspecified, but the description is sufficient for correct invocation.

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

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

Schema description coverage is 100%, so both parameters are already documented. The description mostly restates the include_instruction flag's effect and provides no additional syntax, constraints, or default information beyond the schema.

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

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

The description uses a specific verb ('Fetch') and resource ('capability catalog entry by capability_id'), and enumerates the returned fields. It clearly distinguishes this as a single-entry read tool from list/route 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?

It explicitly says to find capability ids via list_capabilities or route_capabilities and notes the read-only nature and not_found behavior. It does not spell out when not to use it versus alternatives, but the context is 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?

The annotations already declare readOnlyHint and idempotentHint, and the description adds valuable context beyond that: it explicitly promises credentials are never returned, enumerates the visible fields, and documents the not_found failure condition for unknown or invisible IDs. This fully covers behavioral expectations 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?

Three tight sentences with no filler: the resource and return fields come first, the ID-finding guidance follows, and the safety/failure behavior closes the description. 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 single-parameter read tool with no output schema and strong annotations, the description is complete: it names the parameter source, enumerates return fields, discloses credential exclusion, and states the error condition. Nothing essential 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?

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful value by naming connector_id as the lookup key and telling the agent to source it from list_connectors. It also clarifies that an invalid or invisible ID leads to not_found, which enriches the parameter's semantics beyond the schema description.

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

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

States a specific verb ('Fetch'), the exact resource ('one saved connector by connector_id'), and enumerates the returned fields, which clearly distinguishes it from list_connectors, create_connector, update_connector, and delete_connector. The explicit exclusion of credentials further sharpens 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?

Directly instructs the agent to use list_connectors to find IDs, which is the key prerequisite and routing guidance. The failure mode for unknown or invisible IDs also helps the agent decide when this call is appropriate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description reinforces these with 'Read-only and non-destructive.' The additional statement 'not separately rate-limited' adds behavioral context beyond the annotations, and 'public' signals access 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?

Two short sentences front-load the operation and immediately provide usage context. There is no filler; even the rate-limiting note earns its place by adding useful behavioral information.

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

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

For a zero-parameter, read-only, public contract tool, the description covers what it returns, when to use it, and key behavior. The absence of an output schema is mitigated by the explicit 'machine-readable contract' framing, and the annotations cover safety semantics.

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

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

The input schema has zero parametersaine, so there is no parameter burden for the description to carry. The baseline of 4 for zero-parameter tools applies; no additional 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?

States a specific verb and resource ('Get the machine-readable Algenta public contract') and lists the contract's major contents, which clarifies what the tool does. It does not explicitly contrast itself with sibling tools, but its unique resource name and content list make it distinguishable.

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

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

Explicitly says to use it when 'an agent needs the canonical discovery, summary, query, batch, SQL report, governed filter rules, CLI, or MCP entrypoints before planning tool use,' providing a clear usage context. It does not mention when-not-to-use or alternatives, but the context is strong enough for this kind of fetch tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, and the description reinforces these while adding new context: it reads only the active API key's organization and is not separately rate-limited. This goes beyond the structured annotations without contradicting them.

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

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

The description is three sentences, front-loaded with the core purpose, and compact overall. The phrase 'Read-only and non-destructive' somewhat duplicates the annotations, but the rest of that sentence contributes new behavioral detail, so the waste is minimal.

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

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

For a one-parameter, read-only tool with no output schema, the description names the return payload fields (row_count, columns, roles_summary, formulas, query_hints), scoping, and rate-limit behavior. It is sufficient for correct invocation, though 'relationship metadata' is not further elaborated.

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 dataset_id is fully documented in the schema, including its origin from connect_data or list_data. The description mentions that lookup is by dataset_id but adds no new parameter semantics beyond the schema, so the 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 opening sentence states a specific verb and resource: 'Get a saved dataset plus its schema and relationship metadata by dataset_id.' It also distinguishes this tool from get_data_summary by positioning that tool as a 'low-token look' while this returns the full dataset record and schema fields.

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

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

The description explicitly names the alternative get_data_summary and advises using it first for a low-token look, which gives an agent a clear routing path. It does not, however, list broader exclusions or conditions for when not to use get_data_schema, so it stops short of full when/when-not guidance.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds meaningful behavioral context beyond annotations: unknown dataset_id fails with not_found, the meaning of model_tier values, and the returned fields. This fully discloses expected 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?

Every sentence earns its place: purpose, model-tier meanings, usage sequencing, error behavior, and returned fields. It is compact but information-dense, with the primary purpose 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 one-parameter read-only status tool with no output schema, the description is complete: it covers return fields, model-tier interpretation, polling guidance, error behavior, and distinguishes from related actions. Nothing an agent needs to call 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?

Schema coverage for dataset_id is 100%, so the schema already documents the parameter. The description adds value by explaining that an unknown dataset_id produces a not_found error and that the parameter references a dataset from onboard_dataset, reinforcing usage semantics 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 and resource ('Get the live training status and model tier of one dataset') and distinguishes it from sibling status tools by focusing on semantic training and model tier. It clearly says what the tool does without tautology.

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

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

The description gives explicit usage context: poll after onboard_dataset until training completes, and use retrain_dataset after schema or alias changes. This tells an agent when to call this tool and when to use an alternative.

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. The description adds non-obvious behavioral context beyond annotations: it 'reads only the active API key's organization' and 'is not separately rate-limited.' These are meaningful operational details that help an agent decide to call 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?

Three dense but focused sentences: purpose, usage positioning, and return values. Every sentence adds value and the most important routing guidance appears early. No filler or redundancy.

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

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

For a single-parameter, read-only tool with rich annotations and no output schema, the description is complete: it covers when to use it, what it does, its behavioral traits, and the exact fields returned. An agent has everything needed to 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?

Schema description coverage is 100%, so the schema already fully documents dataset_id. The description adds little beyond what the schema provides: it mentions 'saved dataset_id' and the list_data workflow, but this is context already implied by the schema's 'from connect_data or list_data.' 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?

States a specific verb and resource: 'Get the low-token dataset selection summary for a saved dataset_id.' It distinguishes itself by emphasizing 'low-token' and 'selection summary', which sets it apart from heavier tools like get_data_schema or get_dataset_status. This is a clearly differentiated 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?

Provides explicit usage context: 'Use this after list_data(search=..., compact=true) before paying for the full schema payload.' This tells the agent exactly when to invoke it and what to avoid, implicitly naming the alternative (full schema retrieval) without ambiguity.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior; the description reinforces this and adds that it is not separately rate-limited, which is not in the annotations. It also specifies what the return payload includes. This exceeds the baseline but does not discuss error cases or access-control implications, so not a 5.

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

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

Three compact sentences: first states the core operation, second adds safety and rate-limit context, third guides input discovery and return content. Every sentence earns its place; no redundant words or 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 single-parameter fetch tool with rich annotations and no output schema, the description covers what the tool does, how to get the ID, what it returns, and that it is safe. It could mention behavior when the ID does not exist, but that is a minor gap for this simple operation.

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

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

Schema coverage is 100% and the sole parameter decision_id is described as 'Decision ID from log_decision or list_decisions.' The description reinforces this by pointing to list_decisions, but adds no new semantic depth beyond the schema. 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 opens with a specific verb and resource ('Fetch one decision-memory record by id') and clarifies that it returns the full record including context, options, risk fields, and hashes. This clearly distinguishes it from siblings like list_decisions (list), log_decision (create), and delete_decision (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?

It explicitly names list_decisions as the way to find decision ids, telling the agent how to prepare input. It also notes 'not separately rate-limited,' which gives useful operational context. No alternative is needed for a single-record fetch, and the guidance is 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?

Annotations already cover read-only, idempotent, and non-destructive. The description adds meaningful context beyond that: 'not separately rate-limited' (rate-limit behavior) and the full return contract including the null case for shared-pool organizations. No contradictions with annotations.

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

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

Three sentences, each earning its place: purpose, safety/rate-limit note, polling guidance, and return format. Front-loaded with the core verb and resource. No fluff or repetition beyond acceptable reinforcement of the read-only nature.

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

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

Despite having no output schema, the description fully specifies the return shape (fields and null condition) and the intended polling pattern. For a parameterless read-only fetch, nothing an agent needs to call 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?

The tool has zero parameters and the schema is empty, so there are no parameter semantics to clarify. Per the baseline for 0-param tools, the description does not need to compensate for missing parameter docs, and it doesn't introduce any confusion.

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 verb and resource: 'Fetch the current deployment for the active organization, if one exists.' It clearly identifies scope (active organization) and the nullable result. It also distinguishes itself from related siblings like create_deployment by positioning itself as the status-polling counterpart.

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

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

Provides an explicit usage directive: 'Poll this after create_deployment until status is active.' This tells the agent exactly when to call it. It does not explicitly rule out alternatives like get_deployment_cost or delete_deployment, but for this tool's primary purpose the guidance is clear and actionable.

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 behavior beyond the annotations: it discloses that an admin API key is required, that an unknown deployment_id fails with not_found, and explicitly notes 'Read-only.' Since annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, the description's added context about auth and error handling is valuable. 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 three sentences with zero filler. The first sentence front-loads the core purpose and returned fields, the second covers auth and error behavior, and the third gives the prerequisite and read-only note. 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 single-parameter tool with no output schema, the description is complete: it states what is returned (enumerated fields), the required auth, the failure mode, and the prerequisite sibling call. An agent has everything needed to invoke it correctly and interpret the result at a high level.

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

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

The input schema already provides a full description for deployment_id: 'Deployment id from get_deployment.' With 100% schema coverage, the description adds little new semantic detail—it reinforces that the id refers to a deployment from get_deployment and calls it 'active,' but this is marginal. The baseline of 3 applies because the schema carries the parameter documentation 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 clearly identifies the action (get), the resource (current-month cost details of a deployment by id), and enumerates the returned fields (provider, region, cost_usd_month, billable_cost_usd_month, billing_markup_pct, last_updated). It names get_deployment as a prerequisite, which implicitly differentiates it from that sibling, though it doesn't explicitly contrast with other cost-related tools like get_billing_info. Overall the verb and resource are specific enough for an agent to understand what the tool does.

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 preconditions: requires an admin API key, and the agent should 'Use get_deployment to find the active deployment first.' It also states the error outcome for an unknown deployment_id (not_found), which helps the agent anticipate failure. It doesn't explicitly say when not to use this tool or name alternative cost/billing tools, but the context provided is sufficient for a single-purpose lookup.

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. The description adds beyond these by noting 'not separately rate-limited' and explicitly listing the returned fields (min_confidence, risk_floor, require_calibration, allow_reexecution, and snapshot metadata). 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 first sentence states the core purpose and scope, the second adds safety, usage ordering, and return field details. Information is front-loaded and each 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?

With no output schema, the description compensates by listing the exact return fields, which is crucial. It also gives a usage hint. While it doesn't mention error conditions or permissions, for a parameterless read tool this is sufficient. The mention of 'current' policy implies historical snapshots are handled by another tool.

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

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

The tool has zero parameters, so schema coverage is 100% trivially. Per calibration, baseline for 0 parameters is 4. The description does not need to add parameter semantics, and it doesn't, which 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 clear verb ('Get'), a specific resource ('current autonomous execution policy'), and scope ('for the active organization'). It distinguishes from the sibling update_execution_policy by explicitly noting 'Read this before update_execution_policy,' and the resource name itself differentiates from list_execution_policy_snapshots.

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

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

The description provides a clear usage context: 'Read this before update_execution_policy' tells the agent exactly when to call this tool. It also notes it is read-only and non-destructive, implying safe to use in read scenarios. However, it does not explicitly mention alternatives like list_execution_policy_snapshots for historical policy retrieval, though that is a different tool.

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

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

Annotations already establish readOnlyHint, idempotentHint, and destructiveHint. The description adds useful behavioral context beyond these: 'not separately rate-limited' and the requirement that the job must be completed to fetch its result. 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 short and front-loaded, but it contains redundancy: 'Returns the completed job's result payload' restates the opening sentence, and 'Read-only and non-destructive' echoes the annotations. Two of four sentences do not earn their 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 one-parameter tool with no output schema, the description gives enough context: what it fetches, that the job must be completed, how to check progress, and the return value. It does not detail the behavior if called before completion, but this is a minor gap for such a simple read-only tool.

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

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

The input schema fully documents job_id as 'UUID of the async job' with 100% schema coverage. The description only refers to 'by id' and does not add further parameter-level detail, 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 opens with a specific verb and object: 'Fetch the completed result payload for an async simulation job by id.' It is clearly distinct from sibling job-related tools like get_job_status and poll_job, leaving no ambiguity about what this tool retrieves.

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 explicitly says to 'Use get_job_status to check progress before the job completes,' naming the alternative and the condition that selects it. It also notes that the tool is 'not separately rate-limited,' giving practical guidance on when it can be invoked.

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, and non-destructive, so the description adds value beyond them by disclosing 'not separately rate-limited' and by describing the return contents (status, progress, timestamps, poll_url). 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 carry the action, sibling pointer, rate-limit note, and return summary in efficient order. Every clause earns its place; 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-parameter, read-only status tool with strong annotations, the description covers the safety profile, rate limiting, return content, and the relevant sibling for blocking behavior. Nothing an agent needs to call 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?

Schema coverage is 100% and the single job_id parameter is already documented as 'UUID of the async job'. The description adds only the context that this is a status fetch 'by id', which does not materially extend the schema's meaning. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Fetch') and resource ('async simulation job status by id'), and scopes it as 'latest'. It also names sibling poll_job as a different behavior, so an agent can immediately distinguish this from related job tools.

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

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

Explicitly states the alternative: 'Use poll_job to block until a terminal state.' This tells the agent when to choose the sibling instead. It also implies suitable use for non-blocking status checks, though it stops short of a full when-not-to-use list.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false; the description restates 'Read-only and non-destructive' (redundant) but adds valuable context beyond annotations: 'not separately rate-limited' and the specific return fields ('rate, concurrency, storage, and LLM spend cap'). This adds behavioral and output detail beyond the structured metadata.

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 compact, front-loaded with the purpose, and every sentence earns its place: purpose, safety/rate-limit note, sibling routing, and return contents. No fluff or repetition beyond the harmless restatement of read-only/non-destructive.

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 tool with no output schema, the description covers all necessary information: what it does, how it relates to get_usage, rate-limit behavior, and the structure of the returned data. Nothing an agent needs to call 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?

The tool has zero parameters, so the baseline is 4. The description goes beyond by detailing exactly what the tool returns ('quota ceilings, including rate, concurrency, storage, and LLM spend cap'), which fully compensates for the lack of an output schema and gives agents a complete picture of the result semantics.

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

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

States a specific verb and resource ('Get current plan quotas and limits for the active API key') and explicitly differentiates from the sibling get_usage by naming it as the consumption counterpart. The purpose is unambiguous and distinguishes the tool from many other get_* 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?

Explicitly names the alternative tool (get_usage) and the condition for using it ('current consumption against these limits'). Also notes that this tool is 'not separately rate-limited,' which is a practical usage consideration. This gives clear guidance on when to call this tool versus alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds 'not separately rate-limited,' which is a meaningful behavioral detail beyond structured fields. It reinforces rather than contradicts annotations.

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

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

Three sentences with zero filler: purpose, behavioral trait, then alternative and return payload. The most important information (what it does and that it's read-only) 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?

With no parameters and no output schema, the description fully covers what an agent needs to call and understand the response. It lists all returned fields and notes rate limiting, making the tool self-contained.

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 the baseline is 4. The description adds value by enumerating the result fields, which helps set expectations even though there are no inputs 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 states a specific verb and resource ('Get current user and organization identity') and lists the exact return fields, making it unambiguous. It also distinguishes itself from siblings by explicitly naming update_me for modifications, so an agent can tell it apart without opening schemas.

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

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

It explicitly tells the agent to 'Use update_me to change the returned names,' providing a clear alternative for a related mutation. It does not exhaustively contrast with all siblings, but the identity scope is clear and the read-only guidance implies when not to use it for changes.

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/destructiveHint true-family, so the description's 'Read-only and non-destructive' only reinforces them. The added value is the disclosed return shape: supported_languages and support_progress with ranked target counts, progress fraction, and label. No contradictions with annotations.

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

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

Three sentences, each serving a distinct purpose: scope, safety/usage, and output. It is front-loaded with the verb and resource, avoids filler, 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?

With no input parameters and no output schema, the description provides everything the agent needs: what the tool lists, the ranking semantics, and the exact output fields. The workflow hint about create_repository_snapshot completes the context.

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

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

The tool has zero parameters and schema coverage is 100%, so there are no parameter descriptions missing. The description adds no parameter semantics but instead specifies the output contract, which is the relevant contextual information. Baseline 4 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 opens with the explicit verb 'List,' identifies the resource ('globally supported Repository Intelligence languages'), and clarifies that it returns 'ranked support progress.' This is specific enough to distinguish it from generic capability-listing siblings like list_capabilities or list_runtime_libraries.

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 directs the agent to call this tool before create_repository_snapshot, a concrete when-to-use workflow with a named sibling. It doesn't enumerate when not to use alternatives, but the clear precondition provides sufficient 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, covering the safety profile. The description adds behavioral specifics beyond annotations: it states the snapshot is 'immutable' and 'persisted', lists the exact fields returned, and describes the error condition (not_found). This enriches the behavioral understanding without contradicting annotations.

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