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

The description discloses that without confirm it is a read-only preview, and with confirm it attaches to study history. It also states that adoption does not refit, which is a behavioral trait not covered by annotations. Given annotations already indicate non-read-only and non-destructive, this adds useful context about the two-phase 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 primary action (preview), and immediately follows with the conditional confirmation behavior. There is no fluff or redundancy, making it highly 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?

With an output schema present, the description need not explain return values. It covers the preview/attach duality and the non-refit behavior, but it omits the purpose of 'reason' and the meaning of 'provenance gaps', and does not clarify ownership or prerequisites. It is adequate but not fully complete for a tool with 4 parameters and no schema descriptions.

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

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

Schema description coverage is 0%, so the description must compensate for missing parameter explanations. It only clarifies the 'confirm' parameter ('Set confirm only to attach it to study history'). It does not explain 'reason', 'study_id', or 'model_hash' beyond their names, leaving a significant gap for a tool with 4 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 clearly states the tool's function: preview an owned completed model and provenance gaps, then optionally attach it to study history via the confirm flag. The verb and resource are implicit but discernible ('attach it to study history'), and it distinguishes itself from siblings by the unique action of adoption. It lacks an explicit 'adopt' verb but the intent 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?

There is no guidance on when to use this tool versus alternatives. It does imply that without confirm it's a preview, but it doesn't mention any other tools or conditions for selection. No exclusions or comparisons to sibling tools are provided.

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

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

The description goes far beyond the annotations, detailing side effects (appends an audit event), output specifics (returns blockers, evidence hash, includes diagnostics when available), and limitations (external calculations unverified, decision_grade_ready false). It also clarifies it never clears champion blocks. This is consistent with annotations (readOnly=false, so writes are allowed; destructive=false, so non-destructive) and adds substantial behavioral context that an agent would otherwise not know.

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 verbose and runs several paragraphs, packing many technical clauses without clear section breaks or bullet points. While it front-loads the main purpose, the density and jargon (e.g., 'retained_sampling limits', 'holdout_provenance report', 'fresh_validation') make it hard to scan. It would benefit from restructuring to highlight key behaviors and parameter roles.

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 and the presence of an output schema, the description is quite comprehensive. It covers the checks performed, optional behaviors, return values, and limitations. It mentions what is not verified and that decision_grade_ready remains false. It does not elaborate on error conditions or when the tool might fail, but the output schema and annotations cover the expected response, and the description provides sufficient operational context 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 0%, so the description must compensate, but it does not clearly map each parameter to its meaning. It references 'full-model revision' and 'validation pair' which hint at full_run_id and validation_run_id, but it does not explicitly explain study_id, policy_id, or how the IDs relate to the checks described. The description is dense but lacks a clear parameter-to-purpose mapping, leaving agents to infer from context.

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

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

The description clearly states the verb and resource ('Assess a validation pair and append a prediction-access audit event') and lists the checks performed. It also clarifies what it does NOT do ('does not fit, accept or promote') and mentions 'never clears champion blocks', distinguishing it from promotion/acceptance tools. However, it doesn't explicitly name sibling tools like evaluate_study_run or validate_study_recipe, so differentiation is implicit rather than explicit.

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

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

The description provides rich context about when checks apply (e.g., 'when evidence is available', 'Optional prelaunch retained_sampling limits require complete native records', 'Optional require_policy_review checks...') and exclusions ('does not fit, accept or promote', 'decision_grade_ready stays false'). It implies usage scenarios but does not explicitly say 'use this when you need X instead of Y'. The alternative tools are not named, so the guidance is contextual rather than comparative.

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

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

Annotations already convey that this is destructive and non-idempotent. The description adds valuable behavioral nuance by clarifying that cancellation is a request and that 'requested' and 'confirmed stopped' are distinct states, implying an asynchronous or multi-step lifecycle. It does not contradict the annotations.

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

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

The description is extremely concise: two short sentences, with the key action upfront and the important state distinction immediately after. There is no filler or redundant restatement of the tool name.

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 tool with an output schema and rich annotations, the description is mostly adequate. However, it does not explain the cancellation flow, how to confirm the eventual stopped state, or what side effects occur. The state distinction is a useful start but could be more actionable.

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

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

Schema description coverage is 0%, and the description does not mention run_id at all. The parameter name is self-explanatory to a degree, but the description does not compensate for the lack of schema documentation by explaining what run_id refers to, how it should be obtained, or any constraints.

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 ('request') and a clear resource ('cancellation' of a study run), and it distinguishes the requested state from a confirmed stopped state. It does not explicitly differentiate it from sibling tools like update_run or get_study_run, but the core intent 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 gives no explicit guidance on when to use this tool versus alternatives such as launch_study_run, get_study_run, or update_run. The state distinction hints at usage context but does not explain prerequisites, follow-up steps, or which sibling handles confirmed stopping.

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 and destructiveHint=false. The description goes further by disclosing a concrete side effect: 'Serving prediction evidence appends access audit events,' plus behavioral nuances like 'flagged, not ranked' and no model fitting/promotion. 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 short sentences, each earning its place: main purpose first, side-effect disclosure second, exclusions third. No redundant phrasing or filler.

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

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

For a comparison tool with an output schema and three simple params, the description covers the core operation, constraints, side effects, and exclusions. Return-value details are presumably covered by the output schema, so nothing essential is missing for invoking the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It adds useful constraints: run_ids are '2-20 candidates' and policy_id maps to 'one quality policy.' However, it does not explicitly define study_id or provide parameter-level semantics such as id formats or relationships, so compensation is partial.

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

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

The first sentence states a specific verb and resource: compare 2-20 candidates against one quality policy. The closing sentence adds exclusions ('Does not fit or promote models'), which clearly differentiates it from model-lifecycle siblings like adopt_model_into_study and create_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 provides clear context for when to use the tool (multi-candidate comparison against a quality policy) and states what it does not do (fit/promote models, rank different datasets). It does not explicitly name a sibling alternative or give an exact 'use X instead' condition, but the boundary is clear enough for routing.

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 a non-read-only, non-idempotent mutation, so the description carries the burden and exceeds it. It discloses the async queue behavior, immediate model_hash return, unsaved-model visibility ('invisible to list_models unless include_unsaved=true'), strict unknown-key rejection with 400s, and even a silent-ignore footgun for operating_margin_column placed inside a config dict.

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

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

The description is very long, but the complexity (25 parameters, many with nested constraints and 400-level edge cases) justifies most of the length. It is front-loaded with a concise summary and then structured as an Args list with bolded field names and examples. Some sections are dense enough to be slightly hard to parse, but no sentence feels wasted.

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

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

Given 25 parameters, zero schema-level descriptions, no enums, and no sibling differentiation, the description is exceptionally complete. It covers inputs, defaults, validation rules, return value ('Returns the model_hash for status polling'), and points to the correct follow-up tools for status and results.

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 fully compensate, and it does. Every parameter including priors, control_reference, reporting_kernel, sampler, and operating_margin_column is explained with defaults, constraints, examples, and validation behavior — far beyond the bare schema types.

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+resource statement: 'Create and start fitting a new Bayesian Marketing Mix Model.' It clearly distinguishes this from siblings like create_var_model and run_optimizer by specifying it creates a model, queues an async fit, and returns a model_hash.

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: it explicitly says the fit is async, returns immediately, and instructs the agent to 'Use get_model_status to poll for progress until status is "complete"' and later references get_model_results and save_model. It doesn't explicitly contrast with create_var_model or other model-creation siblings, but the async polling guidance is 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 substantial behavior beyond annotations: name sanitization rules, team membership requirements with distinct 403/404 errors, and the 201 response including the created project id. Annotations already indicate a mutating, non-idempotent operation, and the description is consistent with 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 concise, front-loaded with the core purpose, and organized into clear sections: purpose, sanitization note, Args, and Returns. Every sentence adds distinct value with no repetition of schema or annotation 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 two-parameter creation tool with an output schema present, the description covers the essential behavior: display name, sanitation, team-sharing constraints, return status, and how the result connects to save_model. No critical 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 0%, but the description fully compensates by explaining both parameters: 'name' as a display name and 'team_id' as optional sharing with an owned team, including error semantics. This adds real meaning beyond the bare schema types.

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 named project (model folder) to file models into.' This clearly distinguishes create_project from sibling tools like create_model and create_recipe_draft by establishing that a project is a container for models.

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

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

It gives clear usage context: projects are for filing models into, and the returned id is meant to be passed to save_model(project_id=...). It does not explicitly name alternatives or when-not-to-use conditions, but the workflow hint is strong enough to guide appropriate invocation.

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

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

The description goes well beyond the annotations by disclosing important behavioral constraints: no default thresholds, required-check rules, uniqueness of metrics, the R-hat minimum, prediction-window requirements, the holdout provenance caveat, and the fact that agents cannot submit manual sign-off. This gives an agent realistic expectations about what the backend will enforce.

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 the core action and packs many distinct, useful constraints into a dense paragraph. It is efficient but could be improved with light structural separation between check types, validation protocol behavior, and validation rules.

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 high complexity, the description is remarkably complete: it covers all check kinds, parameter relationships, validation-protocol semantics, and important caveats. Since an output schema exists, not explaining return values is acceptable, and the behavioral detail is sufficient for an agent to invoke the tool correctly.

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

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

With schema description coverage at 0%, the description carries the full burden, and it succeeds. It explains core parameter semantics for built-in, custom, boolean, and manual checks, details the validation_protocol object, and clarifies edge cases such as negative custom bounds and WAPE being a fraction.

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: 'Save project-specific checks.' It clearly differentiates this from the sibling list_quality_policies by describing creation-side behavior and enumerating the distinct check types the tool supports.

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 thoroughly explains what the tool can do and the constraints on its use, but it never explicitly states when to choose this tool over alternatives or when not to use it. The intended usage is implied rather than directly framed against sibling tools like list_quality_policies or update_study.

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 idempotent, open-world, non-destructive, and read-write behavior. The description adds valuable context: encryption, validation of version and size, and the immutable link carrying influence through publication. 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 dense paragraph that front-loads the core purpose and then addresses usage scenarios. Each sentence adds value, though the density makes it somewhat packed. 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 complex tool with a nested schema and five parameters, the description covers the main usage paths, idempotency behavior, and validation. The existence of an output schema (not provided) likely covers return values, so missing return details are acceptable. It could be more explicit about study_id semantics but is largely complete.

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

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

Schema description coverage is only 20%, so the description must compensate. It explains draft_id (reuse for idempotency) and source_revision_id (for copying published recipes), but leaves study_id and name without additional meaning. The nested snapshot fields are partially described within the schema itself.

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 ('Save') and resource ('an encrypted authoring draft') and explicitly distinguishes it from publishing, fitting, or consuming an attempt. It also clarifies the tool's role relative to siblings like publish_recipe_draft and update_recipe_draft by describing creation scenarios.

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 usage scenarios: starting from get_recipe_draft_template for new drafts, preserving the snapshot from get_recipe_draft when editing, and supplying source_revision_id when copying a published recipe. It also mentions reusing draft_id for idempotent retries. It does not explicitly contrast with update_recipe_draft, but the create/update distinction is implied.

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

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

Annotations already establish that this is a non-read-only, non-idempotent, non-destructive mutation. The description adds useful behavioral context beyond annotations: the study is created in an existing project and no models are launched, helping the agent avoid assuming side effects.

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

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

Two short sentences with no filler. The main purpose is front-loaded, and the clarifying non-launch behavior is placed at the end where it serves as a useful qualifier without distraction.

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 straightforward creation tool, the description covers the key contextual requirement (existing project) and the most likely confusion (model launching). With annotations and an output schema present, the remaining omissions are mostly parameter semantics, which are partially compensated by clear parameter names.

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

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

Schema description coverage is 0%, and the description does not explain any of the five parameters. Parameter names like name, question, project_id, max_attempts, and max_concurrent are somewhat self-explanatory, but the description adds zero meaning beyond the schema.

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

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

The description uses a specific verb and resource ('Create a study') and adds the scoping condition 'owned by an existing project.' The explicit note 'Does not launch models' helps distinguish this from launch_study_run or run_optimizer.

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 implies the appropriate use context: creating a study under an existing project rather than executing or launching anything. The negative statement 'Does not launch models' provides a clear when-not signal, though it does not name an alternative tool explicitly.

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 non-obvious behavior beyond the annotations: a content-hash mismatch returns 409 and requires a fresh preview, model_snapshot specifications are review-only, and source_revision_id preserves influence ancestry. These details materially improve an agent's ability to anticipate side effects and error conditions.

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 dense sentences with no filler. It front-loads the primary action, then groups optional parameters and specification variants logically so each sentence adds unique 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 complex tool with nested objects and an output schema, the description covers the key behavioral and parameter nuances. It could be more complete by referencing when a draft vs. a frozen recipe is appropriate, but the available annotations and output schema cover much of the remaining context.

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

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

Schema description coverage is low (17%), but the description compensates by explaining why source_revision_id and expected_content_hash are used and by clarifying the two specification kinds (api_mmm vs. model_snapshot). The remaining required parameters (study_id, name, reason) are left self-evident from their names, which is acceptable.

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 action and object ('Freeze a recipe') and the qualifier 'without fitting' communicates the core purpose. However, it does not explicitly distinguish this tool from its close siblings such as create_recipe_draft or revise_study_recipe, so an agent has to infer which one to choose.

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

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

It gives clear conditional guidance for source_revision_id ('when deriving from a published same-study recipe') and explains the consequence of a mismatched expected_content_hash. There is no explicit 'when to use this vs. alternatives' statement, and with siblings like create_recipe_draft in the same domain, that is a meaningful gap.

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

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

Annotations declare readOnlyHint=false and destructiveHint=false, indicating mutation but no destruction. The description adds important behavioral details: it returns a 202-style payload with model_hash, requires polling get_model_status, and notes that unknown keys in var_priors are rejected. It also specifies that fitting starts asynchronously, which is beyond what annotations provide. 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 long but well-structured with a purpose statement, contextual background, a detailed Args section, and a Returns note. Each sentence serves a purpose, explaining either the tool's role or parameter constraints. It's slightly verbose but justified given the 12 parameters and the need to compensate for zero schema coverage. The key 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?

Given the complexity (12 params, no schema coverage, mutation, asynchronous behavior), the description is remarkably complete. It covers prerequisites (dataset content, row count), parameter relationships, defaults for optional params, and the return type with follow-up action. Nothing an agent needs to invoke 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 0%, so the description carries the full burden for parameter documentation. It explains every parameter in the Args section, adding meaning well beyond the schema: e.g., uploaded_file_id must contain every named column, date_column cannot also be a series, endogenous_vars must have at least two, lags requires enough rows, base_variable must be endogenous, etc. This is essential for correct invocation.

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

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

The description clearly states the action: 'Create and start fitting a long-term (VAR) model'. It distinguishes itself from the sibling link_var_model by explaining that this tool creates the model while link_var_model connects it to an MMM. The reference to the MMM's long_run_rollup gives domain context.

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

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

The description provides clear context for when to use this tool: for modeling joint dynamics of series and producing long-run elasticity. It explicitly mentions the follow-up step of linking with link_var_model, which guides the agent on the workflow. However, it doesn't explicitly state when NOT to use this tool or list alternative model-creation tools (like create_model), so it's not fully explicit about exclusions.

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

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

Annotations already provide idempotentHint and readOnlyHint=false, and the description adds behavioral context beyond them: write-scope requires project-owner credentials and create:models, declaration_id idempotency mechanics, revocation of stale revision influence, and the fact that API declarations stay marked as reported. This is rich behavioral disclosure with no contradiction to 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 dense but every sentence earns its place by adding an operational constraint or clarification. Core purpose is front-loaded, followed by prerequisite steps, retry behavior, parameter conditions, and exclusions, with no filler.

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

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

Given a non-trivial six-parameter mutation with zero schema descriptions, the description covers prerequisites, auth, idempotent retry, conditional parameter requirements, validation implications, and non-goals. An agent has enough context to call this tool correctly and to understand follow-up obligations such as fresh validation.

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

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

Schema description coverage is 0%, so the description carries the full burden, and it succeeds: declaration_id is tied to fresh-UUID/retry semantics, source_access_id to an access event from the run, disposition and affected_revision_id to the informed_revision conditional, and reason to explaining actual use. Every parameter receives meaningful semantic guidance beyond its bare title.

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 phrase 'Append a submitter-reported evidence-use declaration' names a specific verb, resource, and scope, and the final sentence explicitly excludes certification/promotion duties, differentiating this from sibling study actions. It also names get_study_prediction_access as a prerequisite, which helps distinguish the read path from this write path.

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 when-to-use instructions: read get_study_prediction_access first, reference an access event from this run, and use a fresh UUID reused unchanged on retry. It also states conditional usage rules for informed_revision versus other dispositions, giving clear operational guidance without requiring the agent to guess.

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

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

Annotations already mark this destructive and non-read-only, but the description adds meaningful context: deleting is irreversible, unlinks MMMs pointing to the model, removes stored artifacts, and returns a specific success payload. It also discloses the 409 error behavior for non-failed models. No contradiction with annotations exists.

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

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

The description is dense but every sentence earns its place: scope, irreversibility, precondition, side effects, return value, and pre-check advice are all included. The most critical warning is front-loaded, and the Args section is clean.

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

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

For a destructive one-parameter API, the description covers allowed inputs, error conditions, side effects, success response, and recommended pre-checks. Even with an output schema present, it explicitly shows the success payload, leaving little for an agent to guess.

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

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

With 0% schema description coverage, the description carries the full burden. It defines model_hash as the hash of the FAILED model to delete permanently, adding the critical status constraint and purpose beyond the schema's bare 'Model Hash' title. It could mention how to obtain the hash or confirm its format, but for a single parameter this is adequate.

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 ('PERMANENTLY DELETE a FAILED model') and clearly scopes the operation to failed models only. This distinguishes it from sibling tools like get_model, rename_model, or unlink_var_model, even without inspecting their schemas.

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

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

The description explicitly says when to use the tool: only for failed models, and explicitly states that any other status returns a 409. It also advises checking with get_model or get_model_status first, giving an agent clear decision 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 reveals many non-obvious behaviors: assessments are immutable, stale model evidence is rejected, external calculations are submitter-reported and not verified, omitted custom values remain unevaluated, and built-in errors are fitted-window rather than holdout. These go far beyond the annotations, which only provide generic hints, and meaningfully shape how an agent should invoke the tool.

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

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

The description is dense but every sentence carries essential operational or behavioral information. It is front-loaded with the core purpose, 'Save an immutable assessment,' and then efficiently sequences the required workflow. There is no filler or 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 the tool's complexity, an output schema, and only generic annotations, the description covers the full lifecycle: initial hash generation, evidence submission, staleness, authentication constraints, completeness semantics, and unsupported edge cases. An agent has enough information to avoid common mistakes and to decide when this tool is appropriate.

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

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

With schema description coverage at 0%, the description compensates by explaining the role of external_evidence and expected_basis_hash, including the ordering dependency and the requirement for finite numeric or strict boolean values. It also clarifies that submissions are submitter-reported. It does not explain run_id or policy_id beyond their names, but the workflow description provides enough context for correct invocation.

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

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

The description opens with a precise action, 'Save an immutable assessment,' which clearly identifies the tool as a write operation for creating a persistent evaluation of a study run. It distinguishes this from read-only sibling tools like list_study_evaluations or comparison tools by emphasizing immutability and submission of evidence. Despite not naming a sibling explicitly, the verb and resource are unambiguous.

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

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

The description provides an explicit two-step workflow: first evaluate without external_evidence to get report.basis_hash, then submit with expected_basis_hash. It also gives important usage conditions such as manual sign-off requiring a signed-in reviewer and being rejected for API keys, plus the no-automatic-champion-promotion caveat. It does not explicitly name alternative tools, but the usage 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 description goes well beyond the annotations: it explains open-world semantics ('missing advertisement is unknown, not unsupported'), warns that advertised features still require permission and budget, and discloses that no model is created and capabilities are not cached across callers. This meaningfully informs how the agent should treat the result.

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

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

Four compact sentences, each earning its place: when to use, what it returns, how to interpret missing/advertised features, and what side effects to expect. The key guidance is front-loaded.

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

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

With zero parameters, rich annotations, and an output schema present, the description is fully sufficient for an agent to select and invoke the tool correctly. It covers timing, interpretation, permission nuance, and non-caching behavior.

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

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

There are zero parameters, so the description carries no parameter burden. The baseline of 4 applies, and the description still helps set expectations about what the returned result represents.

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: 'Discover this caller's connected backend features' and clarifies it returns only backend advertisements for model families, transformations, priors, and workflow operations. This clearly differentiates it from the many sibling tools by scope and intent.

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 this before planning work and explains how to interpret missing advertisements ('unknown, not unsupported'). It does not name exclusions or alternative tools, but none of the siblings compete with this capability-discovery role.

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 readOnlyHint, idempotentHint, and destructiveHint false, so the safety profile is disclosed. The description adds 'Legacy dashboard-saved configs are served verbatim,' which is a behavioral nuance beyond the annotations, but it is terse and cryptic ('#436') and does not explain implications like formatting or transformation.

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 (two sentences) and front-loads the purpose, which is good. However, the second sentence is cryptic and not well structured; it references '#436' and a legacy behavior without context, making it less clear and slightly wasteful.

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

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

For a simple read tool with one parameter and an output schema, the description is minimal. It omits any explanation of the model_hash parameter and does not mention potential error cases or prerequisites. The cryptic legacy note adds confusion rather than completeness. The output schema exists, so return values are not required, but parameter description and edge cases are missing.

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

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

Schema description coverage is 0%, and the description does not mention the model_hash parameter at all. The parameter is named model_hash, which is somewhat self-explanatory, but the description adds no meaning about its format, requiredness, or how to obtain it. With zero coverage, the description must compensate, and it does not.

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

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

The description clearly states the tool reads stored contribution groups for a model, using the verb 'Read' and naming the resource. It distinguishes from the sibling set_contribution_groups, though it does not explicitly name that sibling. The reference to '#436' is cryptic and not helpful.

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

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

The description implies usage (reading contribution groups) but provides no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. It does not mention that set_contribution_groups is the write counterpart or any conditions that would route an agent here.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds value by disclosing the tool's return contract: a JSON Schema specification listing required columns, naming conventions, constraints, and date formats. No contradiction exists, and the behavior is fully consistent with a read-only metadata query.

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 front-loaded: the first sentence states the action and resource, and the second sentence enumerates the return contents with no wasted words. Every sentence contributes useful information, and the structure is easy to parse quickly.

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

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

For a no-parameter, read-only schema tool with an output schema, the description is complete. It tells the agent exactly what to expect in the response, lists the schema's key contents, and needs no additional context to select or invoke the tool correctly.

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

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

The tool has zero parameters, so the input schema is trivially documented at 100% coverage. There are no parameter semantics for the description to clarify, and the baseline for zero-parameter tools is 4; the description appropriately focuses on the return value instead.

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 canonical CSV data schema for Simba MMM input files.' It further clarifies the exact content returned (required columns, naming conventions, constraints, date formats), leaving no ambiguity about what the tool does. It is clearly distinguishable from all siblings, none of which offer a data schema.

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

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

The description provides clear context: this is the canonical schema for Simba MMM input files, which signals when an agent should call it for constructing or validating input data. It does not explicitly name exclusions or alternatives, but no sibling tool serves the same schema-retrieval purpose, so the implicit use-case guidance is adequate.

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

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

Annotations already mark this as read-only and idempotent. The description adds substantive behavioral detail beyond that: it works for any status, the error field is non-null only for failed models, and it lists the configuration echo and its known omissions. This materially helps an agent predict behavior without over-claiming.

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 organized: opening purpose, use cases, returns, and a note about omissions. Every sentence carries useful information, including the critical caveat about omitted create_model inputs. The most important differentiator (works for any status) 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?

Given the simple one-parameter input, the existing output schema, and the annotations, the description covers all decision-relevant details: why to use this over siblings, what the return shape means, and an important limitation of the echo. No critical gap remains for safe 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 provides the parameter name and type with 0% description coverage. The description's Args section adds 'The model hash (any status),' clarifying that this identifier is valid even for failed models. For a single parameter this is adequate, though more detail on how to obtain the hash could be helpful.

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

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

The description begins with a specific verb and resource: 'Get a model's metadata and configuration echo.' It clearly states what the tool returns and explicitly contrasts itself with get_model_results, making its scope unambiguous and differentiating it from a close sibling.

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

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

It gives explicit when-to-use guidance: 'works for EVERY status, including failed models' and contrasts with get_model_results which 'needs complete.' It also explains common use cases: inspect configuration, understand failure, or locate a model. This 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 are minimal (readOnlyHint=false, idempotentHint=false), so the description carries the behavioral burden and does so extensively. It discloses the prediction_window access-audit side effect, availability-false reasons, no-backfill behavior for pre-#629 fits, the Overlap reconciliation semantics, epoch-date encoding, CSV envelope shape, and oversize-result error behavior rather than partial evidence.

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 well-structured — summary line, section bullets, important caveats, then Args — and front-loaded with the core purpose. It is very long, but the length is largely justified by the tool's many sections and edge cases; a little trimming of version-history detail would improve conciseness without losing safety.

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 exceptionally complete for a complex, multi-section read tool: section semantics, availability reasons, channel-keying pitfalls, filter boundaries, opt-in sections, date formats, CSV behavior, and even a fallback instruction to trust sections_available over hardcoded lists. With an output schema present and this level of contextual detail, 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?

Schema description coverage is 0%, but the Args section fully compensates: sections lists options and common values, format describes the CSV envelope, channels explains matching tolerance and which sections it affects, and max_response_bytes/max_grid_points carry precise behavioral semantics. Every parameter is meaningfully explained beyond its bare schema type.

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 line names a specific resource — results from a completed model — which clearly separates this from sibling tools like get_model_status or get_model. The long section catalog further defines the tool's scope, and the optimizer/predictions bullets explicitly point to get_optimizer_results and get_scenario_results for those alternative views.

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 concrete when-to-use guidance: request only needed sections, use 'channel_summary,model_stats' as a common default, read channel_summary first to obtain exact activity-column keys, and pass channels/max_grid_points to bound payload size. It also marks opt-in-only sections and states when filtering applies or does not apply.

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

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

The description goes far beyond the annotations (which already declare readOnly, idempotent, etc.) by explaining subtle behaviors: fit_liveness heartbeat semantics, stall_threshold meaning, that stall_threshold_exceeded does not change status, and how to handle missing liveness data. This level of detail is exceptional and eliminates ambiguity.

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 structured with a clear purpose statement, then details on return values, liveness behavior, and polling guidance. Every sentence adds value; there is no filler. The critical information is front-loaded, and the parameter explanation is appended logically. It is concise for the complexity it covers.

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

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

Given the tool's complexity (liveness, stall thresholds, edge cases) and that an output schema exists (so return format is covered elsewhere), the description is fully complete. It addresses all possible scenarios an agent might encounter: supported vs unsupported backend, absent liveness, stall threshold semantics, and appropriate polling behavior. 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 description coverage is 0%, so the description must fully explain the parameter. It does: 'model_hash: The model hash returned by create_model or list_models.' This adds clear meaning about where to obtain the value, which is essential for correct usage. The description fully compensates for the lack of schema documentation.

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

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

The description clearly states the tool's purpose: 'Check the fitting progress of a model.' It specifies the resource (model) and the action (check status). It also distinguishes itself from sibling tools like get_model_results or get_optimizer_results by focusing on fitting progress, not results. The description is explicit 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 provides clear usage context: it's for polling fitting progress, and explicitly instructs to 'Continue polling with backoff; do not automatically restart a fit.' It also warns about how to interpret liveness data and when not to infer health. While it doesn't name specific alternative tools, the guidance on when to use and what to avoid is sufficient for an agent to decide correctly.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds substantial behavioral context: the overwrite semantics of the latest run, the distinction between decision-math and fitted-convention columns, the stripping of all-None placeholder arrays, and the warning that ObjectiveMarginal and MroiAtOptimized are different quantities. This goes far 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 long but every section earns its place: the two-mode distinction, the column-convention warning, and the parameter explanations are all necessary for correct use. It is front-loaded with the core purpose and mode distinction, then details. Slightly dense, but not bloated.

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 — two modes, multiple result conventions, and a rich output schema — the description is remarkably complete. It explains the top-level keys for both modes, warns about column incompatibility, and clarifies which quantity answers which question. The output schema exists, so return-value details are not the description's job, and the description still adds the interpretive context the schema cannot.

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

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

Schema description coverage is 0%, so the description must carry the parameter meaning. It does: model_hash is 'Hash of the model that was optimized,' and run_id is 'Optional optimization run id from run_optimizer's response' with guidance to pass it to poll a specific run. The description could add a bit more about the format of model_hash, but it fully compensates for the schema gap.

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

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

The description states a specific verb ('Get') and resource ('budget optimization status and results'), and immediately distinguishes two modes: without run_id returns model-level state, with run_id returns a specific run. This clearly differentiates it from siblings like run_optimizer, get_model_results, and get_scenario_results.

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 each form: poll without run_id for the latest model-level state, and pass run_id to poll a specific run's completion. It also warns that a newer run overwrites the latest state, so a poller can lose sight of its own run — a clear when-not-to-use signal.

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, open-world, and non-destructive behavior, so the bar is lower. The description adds useful context: the response is a complete snapshot with a concurrency version, edits should preserve all fields, and the draft is not an executable recipe.

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 adding distinct information: action, editing directive, and state warning. It is front-loaded with the core read operation 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?

Given a single obvious parameter, an output schema, and rich annotations, the definition covers the important non-obvious semantics: completeness, concurrency, and draft validity. It could go further by explaining how the concurrency version should be used when updating, but this is not essential for a read tool.

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

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

The input schema has no property description and the tool description never mentions draft_id, so it doesn't compensate for 0% schema description coverage. The parameter name is self-explanatory, but the description adds no meaning about how to obtain or format the 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 first sentence uses a clear verb ('Read') with a specific resource ('complete authoring snapshot and concurrency version'), going well beyond the tool's title. It also distinguishes the draft-read operation from siblings like get_recipe_draft_template or publish_recipe_draft by emphasizing completeness and draft state.

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 instruction 'Preserve all fields when editing' provides real guidance for a read-then-edit workflow, and the warning that drafts are unvalidated authoring data sets expectations. However, it never names sibling tools or explicitly states when to choose get_recipe_draft over get_recipe_draft_template, get_recipe_revision_authoring, or list_recipe_drafts.

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

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

Annotations already convey read-only, idempotent, and non-destructive behavior. The description adds valuable behavioral context beyond annotations: 'Defaults are not a validated model,' the notion of 'frozen source bytes with verified lineage and an editable data preview,' and an explicit 'Does not create, publish or run anything.' No contradiction with annotations exists.

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

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

The description is compact and front-loaded: it states the primary purpose first, then optional parameters, then downstream usage, then caveats. Each sentence adds information, though the phrasing 'Get complete shared wizard defaults, hash and envelope schema' is slightly dense and jargon-heavy.

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

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

Given the rich annotations and the presence of an output schema, the description covers the essential behavioral and usage details: no side effects, non-validated defaults, source object selection constraints, and the intended downstream call. The main missing piece is family semantics, but the optional parameters and output schema reduce the need for exhaustive return-value documentation.

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

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

With 0% schema description coverage, the description must compensate. It explains the two optional source parameters and their mutual exclusion ('uploaded_file_id or pipeline_version_id (never both)'), but it does not explain the 'family' parameter, its enum values (mmm/var), or how it affects the returned defaults. This is a meaningful gap.

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

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

The description uses a specific verb and resource: 'Get complete shared wizard defaults, hash and envelope schema.' It distinguishes itself from siblings by explicitly stating 'Does not create, publish or run anything' and by referencing create_recipe_draft, making the tool's role as a template/input source 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?

It provides practical usage guidance, including 'Optionally choose an owned uploaded_file_id or pipeline_version_id (never both)' and 'Copy snapshot into create_recipe_draft and preserve unedited fields.' It clearly implies when this tool fits in the workflow, though it does not explicitly compare against alternatives like get_recipe_draft or get_recipe_revision_authoring.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds the 'immutable' property, which informs the agent that the returned data is stable and won't change, providing useful context beyond the structured hints. No contradiction exists.

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

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

The description is a single, front-loaded sentence with zero filler. It conveys the essential purpose in six words, making it exceptionally concise and easy to parse.

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

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

The tool is simple, and an output schema exists to document return values, while annotations cover behavioral safety. However, the description omits parameter explanations, which is a notable gap given the 0% schema coverage. Despite the self-explanatory parameter names, the description alone is minimally adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. However, the description does not explain that recipe_id identifies the recipe and number is the revision number. While the parameter names are self-explanatory, the description adds no explicit clarification, leaving the agent to infer semantics from names 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 clearly states a specific verb ('read') and resource ('one exact immutable recipe revision'). It distinguishes itself from sibling tools like get_recipe_draft and list_recipe_drafts by emphasizing 'exact' and 'immutable', making it unambiguous which operation is intended.

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

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

The description implies usage for retrieving a specific, immutable revision, but it does not explicitly state when to use this tool versus alternatives like get_recipe_draft or list_recipe_drafts. The context is clear but not contrasted with exclusions, so it relies on inference rather than explicit guidance.

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

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

The description adds substantial behavioral context beyond the annotations: the snapshot is frozen, the published revision remains unchanged, legacy revisions without authoring state return an explicit unavailable error, and the tool does not create or fit anything. This meaningfully informs an agent about side effects, limits, and error behavior.

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

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

The description is three sentences, front-loaded with the core read action, and each sentence serves a distinct purpose: describing the resource, giving the primary usage workflow, and noting error behavior. There is no padding or repetition of schema details.

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

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

Given the output schema exists and annotations already indicate read-only, idempotent behavior, the description covers the main usage flow and an important edge case (legacy revisions). It could be slightly more explicit about what 'authoring state' means and how the snapshot maps to create_recipe_draft, but overall it is sufficient for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented recipe_id and number parameters. It indirectly implies that 'number' refers to a revision number and that 'recipe_id' identifies the recipe, but it never explicitly defines either parameter's meaning, format, or relationship to the returned snapshot.

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

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

The description names a specific action ('Read a frozen authoring snapshot') and a specific resource type ('published draft revision'), and explicitly distinguishes itself from mutating or creating tools with 'Does not create or fit anything.' This clearly separates it from siblings like get_recipe_revision while stating its scope.

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

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

The description specifies that the snapshot should be used with create_recipe_draft to edit a new copy, giving an explicit workflow and intended context. It also warns about legacy revisions returning an unavailable error, but it does not name alternative tools for cases where authoring state is not needed, such as get_recipe_revision.

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, openWorldHint, and non-destructive behavior. The description adds meaningful behavioral context beyond these: a newer run overwrites the latest scenario, and failed scenarios return an HTTP 200 with status 'failed' plus an error message in the body, so callers must check the status field.

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 lengthy but earns its length: mode-by-mode behavior, a critical failure-mode note, and an Args block. The core distinction between the two forms is front-loaded, and every section adds necessary information with no filler.

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

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

An output schema exists, so detailed return-value documentation is unnecessary. For a two-mode polling tool, the description covers overwrite semantics, failure representation, run_id provenance, and when to use each form, leaving no practical gap for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It explains model_hash as the hash of the model the scenario was run on, and defines run_id's format ('scn_...') plus where to obtain it: from run_scenario's response or list_runs(artifact='scenario'). This fully covers both 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-resource pairing ('Get scenario prediction results') and then defines two distinct behaviors: model-level latest state versus a specific saved run identified by run_id. This clearly distinguishes it from run_scenario and list_runs, which are the most related 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?

The description explicitly states the condition for each invocation form: without run_id returns the latest scenario state with overwrite risk, while with run_id fetches a specific saved run. It also says directly, 'Poll THIS form when you need to know whether your own run completed, or to disambiguate back-to-back scenarios,' which is unambiguous usage 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 goes beyond the readOnlyHint and idempotentHint annotations by warning that template data may contain NaN/null values that must be replaced with 0 or the prediction will fail. It also discloses the presence of operating_margin, variable_transforms, and periodicity, adding behavioral context not available from annotations alone.

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 longer than average but well organized: a purpose sentence, response contents, an IMPORTANT block, a warning, and an Args section. There is minor redundancy between the initial response summary and the later IMPORTANT enumeration, but each section adds useful information and the critical usage directive 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 2-parameter tool with an output schema, this description covers prerequisites (completed model hash), intended call order, return fields, NaN handling, and parameter defaults. Nothing critical for invoking the tool correctly is missing.

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

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

With schema description coverage at 0%, the description compensates by defining model_hash as 'Hash of a completed model' and periods_forward as the number of future periods to generate with a default of 12. This adds some meaning beyond the bare schema types, though the model_hash explanation remains somewhat terse.

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 — 'Generate a forward-period scenario template from a completed model' — and immediately differentiates itself from sibling execution tools by naming run_scenario and run_optimizer. The description also itemizes the template's contents, so an agent understands exactly what resource is produced.

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 directive: 'IMPORTANT: Always call this before run_scenario or run_optimizer to discover...' This clearly states when to use the tool. It also enumerates what information to extract (channel names, average CPM, baseline rows, classification) and warns about downstream failure, which is strong pragmatic 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, openWorldHint, idempotentHint, and destructiveHint=false. The description adds useful context by mentioning the optimistic concurrency version, which is relevant for subsequent update operations. No contradiction with annotations exists.

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

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

The description is a single front-loaded sentence with no filler. Every phrase earns its place, and the concurrency-version detail is packed in without bloat.

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 simple one-parameter read operation with strong annotations and an output schema, so the description does not need to explain return structure. It is mostly complete, though explicitly connecting study_id to the study selection would remove the only remaining ambiguity.

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

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

Schema description coverage is 0%, and the description does not explain study_id beyond the generic 'a study.' While the parameter name and title are fairly self-evident, the description adds no detail about the ID format, requiredness, or how the concurrency version relates to 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 states a specific verb ('Read') and resource ('study'), and adds that the tool returns the study's optimistic concurrency version. This clearly distinguishes it from siblings like list_studies (which lists) and get_study_run (which reads a run, not a study).

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

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

The 'Read a study' framing makes it clear this is for retrieving a single study by ID, implicitly separating it from list_studies and study-run-level tools. However, it does not explicitly name alternatives or state when not to use it.

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

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

Annotations already mark this as readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds substantial behavioral nuance: stale champion handling, holdout-use blocking, validation resolution effects, reviewer-declared references, and the frontend-session limitation. It enriches the agent's understanding of data semantics beyond the annotations without contradicting them.

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

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

The description is dense but not bloated. It front-loads the core purpose in the first sentence, then layers important caveats and constraints. Each sentence adds information relevant to correct invocation or interpretation. It is appropriately concise for the amount of behavioral detail it conveys.

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

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

An output schema exists, so return-value documentation is not required. The description covers the key data aspects (incumbent, blockers, candidates, history) and important edge cases (stale champions, holdout blocking, validation resolutions, session limitations). It is complete enough for an agent to understand what this tool returns and the conditions that affect its results.

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 0% description coverage, so the tool description must compensate. It does not mention study_id at all, leaving the agent to infer its meaning from the parameter name. For a read tool with a single obvious parameter, the lack of explicit explanation is a minor gap, but given the low coverage, the description fails to add any value beyond the schema.

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

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

The description opens with a clear verb and resource: 'Read incumbent, eligibility blockers, accepted candidates and immutable champion history.' This precisely states what the tool returns and distinguishes it from other study-related tools like get_study or get_study_run by focusing on the champion concept. The purpose 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 behavioral context (e.g., 'Ordinary viewing does not block', 'Selection/replacement/revocation require an owner frontend session') that implies this is a read-only query tool. However, it never explicitly names alternative tools or states when to prefer this over a sibling like get_study. Usage guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior, and the description adds substantial value beyond them: it confirms the absence of side effects, discloses coverage blind spots, and provides interpretive caveats about what the data can and cannot prove. 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?

Four short sentences, each earning its place: core purpose, negative behavior, coverage limits, and interpretation caveat. The most important information is front-loaded and there is zero redundancy or filler.

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

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

For a compliance-relevant read tool with rich annotations and an output schema present, the description is remarkably complete. It covers the critical interpretive pitfalls (absence of history doesn't prove holdout untouched; repeated access doesn't prove retuning) which is exactly the context an agent needs. Return structure is covered by the output schema.

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

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

Schema coverage is 0%, so the description must compensate. It does so by clarifying that run_id identifies 'this run' and that the access history is scoped to the run plus matching recorded dataset/windows in the study. It doesn't detail the run_id format, but for a single obviously-named required parameter this is adequate compensation.

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

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

The description states a specific verb ('Read'), a specific resource ('partial prediction-access history'), and precise scope ('for this run and matching recorded dataset/windows in this study'). It also distinguishes itself from siblings by stating what it does not do ('Does not expose predictions or add access events'), differentiating it from tools like declare_study_holdout_use.

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

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

The description gives clear context about what the tool covers and, importantly, what it does not cover ('Earlier activity, other result routes and offline work are not covered'). It implies when not to rely on it ('absence never proves untouched holdout status'), but it does not explicitly name alternative tools or state direct when-to-use conditions.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds that the tool returns durable status and the linked model, which is useful context, but it does not clarify what 'durable' means or describe other behavioral constraints.

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

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

The description is a single focused sentence with no filler. The core action and key output are front-loaded, making it easy for an agent to parse quickly.

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

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

For a one-parameter read tool with strong annotations and an output schema, this is nearly complete. The only slight gap is the ambiguity of 'durable' and the lack of any link to the broader study context, but the agent has enough 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 has one parameter, run_id, with 0% description coverage, and the tool description does not compensate by explaining the parameter's meaning, format, or source. The property name is self-evident, but the description adds no value beyond the schema.

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

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

The description names a specific verb ('Read') with a clear object ('durable run status') and a distinct output ('the linked model'). This differentiates it from sibling getters like get_model_status or list_study_runs.

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

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

No guidance is given about when to use this tool versus alternatives. The sibling list includes several related read tools, but the description does not name them or state any exclusions.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, but the description adds valuable behavioral details beyond that: no audit serving event is added, no model is fitted or promoted, and statuses are re-evaluated against exact evidence. It also clarifies the human-only nature of sign-off and revocation. No contradiction with annotations exists.

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

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

The description is three purposeful sentences with the primary action front-loaded. Each sentence adds distinct value: the read scope, the human-only limitation, and the side-effect guarantees. There is 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?

With an output schema present, rich annotations, and a single obvious parameter, the description covers purpose, side effects, and usage limitations well. The only meaningful gap is that study_id is undocumented in both the schema and the description, which slightly reduces completeness for an agent encountering this tool cold.

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

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

Schema description coverage is 0%, and there is one required parameter, study_id. The description does not mention study_id at all, nor does it explain what values are valid or how the parameter scopes the returned resolutions. The parameter name is self-evident, but the description does not compensate for the missing schema documentation.

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

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

The description opens with a specific verb and resource: 'Read analyst validation resolutions and revocations'. It also clarifies the scope with 'current/stale/revoked status re-evaluated against exact evidence', which distinguishes it from nearby assessment or evaluation tools like assess_study_validation_pair or list_study_evaluations.

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 when-not boundary: 'API keys cannot supply human independence sign-off or revoke it; use the signed-in owner UI.' This tells an agent not to attempt sign-off or revocation through this API. However, it does not explicitly compare this tool to sibling MCP tools for reading validation data, so it stops short of full 5.

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, covering the safety profile. The description adds useful non-obvious context: it returns a structured column schema and that this avoids re-reading the CSV for model building. This goes beyond what annotations alone provide 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 front-loaded with the purpose, followed by a compact return list and a clear Args section. Despite listing many fields, every sentence earns its place because it helps the agent know exactly what will be returned and how to use it. 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?

Given the single parameter, the safe-read annotations, and the rich output schema, the description is complete for tool selection and invocation. It explains the parameter source, the return contents, and the downstream use case, leaving no practical gap for an agent to call this tool correctly.

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

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

The input schema provides only 'integer' and 'File Id' with 0% description coverage, so the description must carry the semantics. It does: 'The upload's id, from upload_data's response or list_uploads.' This fully explains the parameter's meaning and provenance, which is exactly what an agent needs.

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

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

The description begins with a specific verb and resource: 'Get one uploaded dataset's details, including its column schema.' This clearly distinguishes it from list_uploads (which lists uploads) and upload_data (which creates an upload). The resource and output are unambiguous.

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

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

The description gives clear context on when this tool is useful: it explains that the returned columns can be used to build create_model's channel/control arguments without re-reading the CSV. It also specifies where to obtain file_id (from upload_data or list_uploads). It stops short of naming alternatives or explicit when-not-to-use cases, so it does not earn a 5.

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 and readOnlyHint=false, and the description adds concrete behavioral detail beyond that: reuse the same submission_key after an ambiguous response and never invent another key. It also discloses conflict handling ('Budget/state conflicts require inspection') and prerequisites that annotations cannot express.

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

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

The description is four dense sentences with no filler. The core purpose is front-loaded, and each sentence adds a distinct operational constraint: prerequisites, conflict handling, and idempotent retry behavior.

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

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

With an output schema present and annotations covering idempotency/side-effect characteristics, the description covers the remaining essentials: prerequisites, budget/state conflict guidance, and retry semantics. Nothing critical is missing for an agent deciding whether 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?

Only the submission_key parameter has schema documentation (25% coverage), but the description supplies meaning for the others: 'active study' qualifies study_id, 'immutable executable revision' defines revision_id, and 'same-study policy' constrains policy_id. This partially compensates for the sparse 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 opens with a specific action and object: 'Launch a frozen revision within study attempt/concurrency budgets.' It also adds distinguishing constraints (active study, immutable executable revision, same-study policy) that separate this from generic run tools like run_scenario or run_optimizer.

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 lists prerequisites: 'Requires an active study, immutable executable revision and same-study policy.' It also gives direct when-to-use and when-not-to behavior: budget/state conflicts require inspection rather than a new attempt key, and the same submission_key must be reused after an ambiguous response.

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

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

Annotations already signal destructive and non-idempotent behavior, but the description goes far beyond them: it explains the post-link effect on get_model_results, the at-most-one-MMM constraint, the error behavior naming the current owner, strict validation rules, channel_map replacement semantics, and clearing on unlink. This is rich behavioral disclosure.

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

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

The description is long but structured and front-loaded with the core purpose before diving into details. Every sentence adds operational value, though the depth of detail around channel_map and validation makes it denser than strictly 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?

For a linking tool with destructive semantics and non-trivial validation, the description covers the full context: prerequisites, result effects, constraints, error behavior, parameter semantics, and state lifecycle. The existing output schema covers return value details, so 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 description coverage is 0%, so the description carries full responsibility. It clearly defines model_hash as the MMM to attach to, var_model_hash via create_var_model, and channel_map with its type, purpose, validation rules, and lifecycle. The description compensates completely for the sparse 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 first sentence names a specific verb and resource: 'Link a completed VAR model to an MMM'. This clearly distinguishes it from the sibling unlink_var_model and other model-management tools. The subsequent explanation of what linking does to results makes the tool's role 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 gives clear context for when linking is appropriate, including the one-link-per-VAR constraint and the channel_map requirement for group-level VARs. It mentions 'unlink clears it', implicitly pointing to the sibling unlink tool, though it never explicitly instructs the agent to use unlink_var_model for removal.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful behavioral detail beyond the annotations: it lists the returned fields, statuses, type values, hierarchy value, and timestamps, and explains the hash convention across related endpoints. This gives the agent a meaningful picture of what to expect without contradicting the annotations.

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

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

The description is well structured and front-loaded: purpose first, then return values, then the critical identifier note, then parameter documentation. Every sentence adds value, and the Args block is concise and directly useful. No redundant 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?

For a read-only list endpoint with an output schema and comprehensive annotations, the description is complete. It explains the authenticated-user scope, the key fields returned, the model_hash convention that matters for all downstream calls, and all pagination and filtering parameters. Nothing an agent needs to invoke this tool correctly is missing.

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

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

Schema description coverage is 0%, so the description carries the full burden for parameter semantics. It fully compensates by explaining include_unsaved as 'draft/unsaved models', limit as 'maximum number to return' with a max of 500, and offset as 'number of models to skip, for paging past limit.' This goes well beyond the bare schema properties.

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: 'List all Marketing Mix Models for the authenticated user.' This clearly identifies the operation and scope, and the resource name differentiates it from sibling list_* tools such as list_studies, list_uploads, and list_projects.

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 usage context by explaining that all other model endpoints use model_hash and instructing the agent to use the model_hash from this response. It does not explicitly name alternative tools or when-not-to-use conditions, but the hash-identifier guidance strongly implies this tool is the entry point for model operations.

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

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

Annotations already declare readOnly and idempotent, so the safety profile is covered. The description adds semantic detail: team-shared folders carry 'shared': true, and model_count counts only SAVED models (the set the app's model list shows). It also discloses an intentional API limitation (no deletion), going beyond the structured hints.

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

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

The description is a compact block that front-loads the core purpose in the first line, then efficiently provides output shape, field meanings, usage pointers, and a limitation. Each sentence adds distinct information and none are redundant.

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

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

For a parameterless listing tool with an output schema, the description explains the return fields and their interpretation (e.g., model_count counting SAVED models), and connects to related tools. The only remaining context lies in the output schema itself, which is provided separately, so nothing needed by an agent 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 schema describes all parameters (none) and there is nothing for the description to add about inputs. Per the 0-param baseline, a score of 4 is appropriate; the description instead clarifies the return payload semantics.

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

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

The description opens with a specific verb and resource: 'List the projects (the app's model folders) you can file models into.' It distinguishes projects from other entities by framing them as model folders, and the return format clarifies this is a read-only list tool, separate from list_models and similar 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 states that the returned ids should be used with save_model and rename_project, giving an immediate use case. It also notes there is no delete over the API, telling agents to use the app instead. It doesn't explicitly contrast with sibling list tools, but the context is sufficient.

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, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the domain fact that quality policies are 'immutable', which is useful, but it does not explain return behavior, ordering, or how policies come to exist.

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

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

The description is one short sentence with no wasted words. The verb 'Read' is front-loaded, and the resource and scope are stated immediately.

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

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

For a simple read-only tool with one required parameter, an output schema, and safety annotations, the description is nearly complete. It identifies the resource, the scope, and the immutability of the returned policies. The only real gap is that it does not point the agent to `create_quality_policy` for creating policies, but that is a usage-guidance concern rather than a critical invocation blocker.

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

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

Schema description coverage is 0%, so the description must compensate. It maps the action to 'the study', which corresponds to `study_id`, but does not explain where the ID comes from or how it is validated. The single parameter is self-evidently the study identifier, so minimal compensation is acceptable.

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

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

Description states a specific verb ('Read'), resource ('quality policies'), and scope ('for the study'). It is immediately distinguishable from the sibling `create_quality_policy` by virtue of the read/creation contrast, and no other sibling reads quality policies.

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

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

Usage is implied through the verb 'Read' and the scope 'for the study', but there is no explicit guidance such as 'use when you need to view policies; use create_quality_policy to create them.' The description does not mention alternatives or exclusions, so the agent must infer 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 already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds value by noting it does not load datasets (scope limitation) and that it requires checking backend capability first, which is useful behavioral context 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?

Two concise sentences, front-loaded with the core action and limitation. Every word earns its place; 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?

The tool has a simple input schema (one required parameter) and rich annotations, so the description is nearly complete. The mention of checking backend capability is a useful prerequisite, and the limitation about not loading datasets is clear. The only minor gap is lack of detail on the return format, but an output schema exists, so this is acceptable.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented parameter. The description does not add any specific meaning to the 'study_id' parameter beyond what the schema provides (it's a required string). However, the description implies the parameter identifies the study for which drafts are listed, which is a minimal addition but still leaves the parameter semantics largely unspecified.

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 it lists study draft metadata without loading datasets, which clarifies the tool's scope and distinguishes it from tools that load full datasets. However, it does not explicitly name sibling alternatives like get_recipe_draft or create_recipe_draft, so differentiation is implied rather than explicit.

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

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

The description mentions checking backend draft capability first, which provides some usage context, but it does not specify when to use this tool versus alternatives or when not to use it. No explicit guidance on selecting between list_recipe_drafts and other list/get tools is provided.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description discloses important behavior: count is only the page length, ordering is pinned-first then newest-first, null metrics are omitted, and the optimizer objective is intentionally absent from summaries. These details prevent incorrect assumptions during use.

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 tightly organized: a clear purpose, a structured return-value breakdown, explicit caveats, and a compact args section. Every sentence provides actionable information, and the caveats are prominently separated rather than buried.

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

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

The description covers the operation's scope, return shape, field semantics, paging pitfalls, missing-data caveats, and relationships to sibling tools. Even with an output schema present, it supplies enough context for an agent to call the tool correctly without further exploration.

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%, but the description fully compensates: artifact is explained with expected prefixes ('optimizer' for 'opt_...', 'scenario' for 'scn_...'), model_hash is defined as the model whose history to list, limit includes clamping behavior and default, and offset explains paging. This adds meaningful semantic value absent from 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 opens with a specific verb and resource: 'List a model's saved optimizer or scenario run history.' It clarifies this is a listing operation that returns run summaries, not full results, which distinguishes it from sibling tools like get_optimizer_results and get_scenario_results.

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 the agent to alternatives: 'Use get_optimizer_results / get_scenario_results with a run_id to fetch a listed run's full inputs and results; update_run / set_run_pinned to curate it.' It also provides paging guidance with the caveat to page until a short page, making the intended usage clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds some behavioral scope by indicating the listing includes questions, budgets, and access rights, but it does not disclose pagination, permission requirements, or other runtime behavior. With strong annotations, this is adequate, not exceptional.

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

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

A single short sentence carries the core purpose and scope with no filler. The action is front-loaded and the object list is compact, 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 simple read-only one-parameter tool with an output schema and strong annotations, the definition is nearly sufficient. However, it lacks usage guidance versus sibling listing tools and leaves the parameter semantics to inference, so there are clear gaps an agent must resolve elsewhere.

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

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

Schema description coverage is 0%, so the description needs to add meaning to project_id. The phrase 'project-owned' loosely implies the parameter filters by owning project, but it does not explain the expected integer's source (e.g., from list_projects), format, or any constraints. This is insufficient compensation for an undocumented parameter.

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

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

The description uses a concrete verb ('List') and names the resource ('studies') plus additional returned categories ('questions, budgets and access rights'). It clearly identifies project-owned scope, which differentiates it from create_study/get_study, though it doesn't explicitly name those 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?

The description does not provide any when-to-use guidance or explicitly contrast with sibling list tools like list_study_recipes, list_study_runs, or list_recipe_drafts. The only hint is 'project-owned' and the required project_id, which implies a project-scoped listing but gives no exclusions or alternative conditions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds some content context by specifying that the read returns analyst decisions and agent recommendations, but it does not disclose ordering, scoping behavior, or other runtime caveats. Given the annotations, this is adequate but not rich.

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

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

The description is a single eight-word sentence with no filler. It front-loads the operation and identifies the key content types, making it appropriately sized for a simple read tool.

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

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

The tool is low-complexity: one required parameter, strong safety annotations, and an output schema is present, so return value details need not be in the description. The main gap is a lack of explicit differentiation from sibling decision-related tools, but the description and schema together give an agent enough to invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate by explaining study_id, but it never does. The phrase 'study decisions' weakly implies the study scoping, and the parameter name is self-explanatory, but no actual parameter semantics are added beyond the input schema. With low coverage, this compensation is required and missing.

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

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

The description clearly identifies a read operation ('Read') over a specific resource ('analyst decisions and agent recommendations'), which goes beyond the title by naming two content types. An agent can distinguish it from list_studies and similar list tools. It does not explicitly contrast with siblings, so it falls just short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives. The sibling list includes recommend_study_run, get_study_validation_resolutions, and compare_study_runs, but the description does not explain why list_study_decisions is the appropriate choice or when another tool would be better. This is effectively no usage 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 a meaningful behavioral trait: 'Serving available prediction reports appends access audit events.' This goes beyond the annotations by explaining why the operation is not purely read-only. It adds useful context about side effects beyond what readOnlyHint=false already implies.

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 front-loaded with the primary read action. The second sentence is somewhat terse and awkwardly worded, but there is no unnecessary 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 one-parameter list/read tool with an output schema, the core action and the audit side effect are stated, which makes the tool minimally usable. However, it lacks usage guidance and any parameter elaboration, leaving clear gaps in the context an agent needs to confidently select and invoke it.

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

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

The single parameter run_id has no description in the schema, and the tool description never mentions it. While the name is fairly self-explanatory, the 0% schema description coverage means the description should compensate, and it does not clarify expected format, meaning, or scope.

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: 'Read preserved quality reports and evidence hashes,' which clearly indicates a read/list operation on study evaluation artifacts. However, it does not explicitly differentiate this tool from siblings like list_study_decisions or get_study_run, so it stops short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives, no preconditions, and no exclusions. The second sentence mentions a side effect of serving reports but does not help an agent decide when this tool is the right choice.

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

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

Annotations already signal readOnly, idempotent, and non-destructive. The description adds what the response includes (effective priors, settings, data hashes) and explicitly states raw datasets are omitted, which is helpful behavioral context beyond the schema. It does not contradict the annotations.

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

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

Two short sentences, front-loaded with the verb and scope, followed by a precise inclusion/exclusion statement. No filler or repetition of annotation hints.

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 rich annotations, an output schema, and a single obvious parameter, the description is nearly sufficient for correct invocation. It covers scope, content, and the raw-dataset exclusion. Minor gaps remain: no ordering/pagination note and no explicit relationship to the recipe-draft tools, but these are not required for a basic read-only list.

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 only study_id with no description (0% coverage), and the description never explains what study_id refers to or how it shapes the returned revisions. The parameter is simple and self-descriptive, but the description adds no parameter-level meaning and does not compensate for the schema's lack of documentation.

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

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

The description opens with 'Read all recipe revisions,' a specific verb and resource, and clarifies scope ('all') and content ('exact effective priors, settings and data hashes'). The explicit exclusion of raw datasets prevents confusion with upload/list_uploads tools. It distinguishes from sibling list_recipe_drafts by focusing on revisions rather than drafts.

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

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

The description implies the tool is for reading the full set of recipe revisions for a study, and the 'Raw datasets are omitted' sentence gives one boundary, but it never explicitly states when to prefer this over get_recipe_revision or list_recipe_drafts, nor does it name alternatives. Usage must be inferred from the tool name and purpose.

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

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

The annotations already establish read-only, idempotent, and non-destructive behavior, while the description adds substantial non-obvious semantics: budget presence is backend-dependent, missing budget means unknown support rather than permission, and capacity is rechecked at reservation. This is exactly the kind of 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?

Three dense sentences with no filler and the core purpose front-loaded. The budget and capacity details are packed efficiently, though the final sentence about recovering an uncertain launch is somewhat tangential to the act of listing.

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

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

For a read-only list operation with one input parameter and an output schema, the description covers the essential scope and the most important non-obvious behaviors. It is complete enough to invoke correctly, though it leaves the relationship to sibling tools like list_runs implicit.

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

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

Schema description coverage is 0% and the description does not mention study_id at all, so no parameter-level meaning is added beyond the input schema. The single parameter is self-explanatory from its name and schema title, which softens the gap, but the description still fails to compensate for low schema coverage.

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

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

The description names a specific verb and resource: 'List preserved attempts including pending and failed runs.' This clearly distinguishes it from single-run tools like get_study_run, but it does not explicitly name a sibling alternative, so it falls just short of a top score.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as list_runs or get_study_run. The budget and capacity notes explain how to interpret results, not when this tool should be chosen.

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, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description goes well beyond these by revealing behavioral specifics: the ordering, the inclusion of non-API sources, the true count semantics, pagination behavior (limit/offset), and the omission of column details. No contradiction exists; the description adds significant value.

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

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

The description is well-structured: it opens with the core purpose, then covers the return shape and key behavioral differences, and finally lists parameters. Every sentence adds value—there is no fluff. The contrast with list_runs and the pointer to get_upload are concise and purposeful.

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 output schema is present (has_output_schema: true) and the description already details the return structure, pagination, filtering, and caveats, the definition is complete for an agent to call this tool correctly. It even points to get_upload for missing details, covering all likely follow-up needs.

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

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

Schema description coverage is 0%, so the description carries the full burden of explaining parameters. It does so explicitly: 'limit: Page size (API clamps to 1-500; default 50)', 'offset: Rows to skip (paging)', and 'name: Optional case-insensitive substring filter on the original filename.' This fully compensates for the lack of schema 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 ('List'), a specific resource ('datasets in your workspace'), and an ordering ('newest first'). It also clarifies the scope ('every source, not just API uploads') and explicitly contrasts with list_runs regarding count semantics, which distinguishes it from a sibling tool without ambiguity.

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

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

The description implies when to use this tool (to list uploads) and provides a clear alternative for a specific need: 'fetch one upload with get_upload for those' when column names/dtypes are required. It also contrasts with list_runs on the meaning of 'count', which is helpful for routing. However, it does not explicitly state 'use this when you need to list uploads' or list exclusions for other scenarios.

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

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

Annotations already signal idempotency, open-world behavior, and non-read-only semantics, and the description adds substantial context: immutable revisions, atomic batch publication, snapshot compilation, frozen MMM priors on capable backends, VAR evidence requirements, invalid-calibration failure, and preservation of disabled observations. 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?

The core purpose is front-loaded and most caveats are relevant, but the description is a dense block of domain warnings and includes an unclear fragment ('Does not fit, consume an attempt or designate a champion'). It is compact but not cleanly structured or fully readable.

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