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

La descripción revela que Power BI Desktop descargará el visual de AppSource al abrir el informe, algo no obvio y útil. También explica el comportamiento por defecto sin argumentos. No contradice annotations porque no hay.

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?

Dos frases directas y al grano. La información está bien priorizada: propósito, comportamiento por defecto, y nota sobre descarga.

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?

La descripción es útil pero incompleta: no explica los parámetros más allá del caso vacío, ni menciona requisitos previos o efectos secundarios. Aunque hay output schema, los parámetros de entrada siguen sin aclararse.

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?

El esquema tiene 2 parámetros sin descripciones (cobertura 0%). La descripción solo aclara el caso sin argumentos y el visual por defecto, pero no define qué es visual_id ni request_id, ni cómo se usan.

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?

La descripción establece claramente que la herramienta registra un custom visual de AppSource en el informe, mencionando 'publicCustomVisuals'. Distingue su función de otras herramientas de visuales al especificar la fuente (AppSource) y el comportamiento por defecto.

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 menciona explícitamente alternativas, pero sí indica el caso sin argumentos y el contexto de AppSource. Falta una guía de cuándo usar en lugar de herramientas como pbi_create_html_visual.

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

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

With no annotations, the description carries the full burden. It adds a determinism guarantee ('Determinista: la misma entrada produce siempre la misma salida'), which is useful. However, it does not disclose that this is a mutating operation, whether it replaces existing positions, or any side effects, so transparency remains limited.

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, with two clear sentences. The edge values are presented in a structured inline list, and there is no filler or repetition. It earns its place by delivering the core purpose and a behavioral guarantee 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?

For a 4-parameter tool with no annotations, the description is too sparse. It omits usage guidance, parameter details for most arguments, and any context on how alignment affects the page. The determinism note is nice, but it does not compensate for the missing operational context, making the tool under-specified for reliable selection and 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 only the 'edge' parameter with valid values, while page, visual_ids, and request_id are left to inference. The alignment action implies visual_ids gives targets, but the lack of explicit semantics for three of four parameters is a significant gap.

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

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

The description clearly states a specific action: 'Alinea varios visuales por un borde' (aligns multiple visuals by an edge). It includes a concise list of valid edge values, which differentiates it from sibling tools like distribute_visuals or arrange_visuals that handle other layout operations.

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

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

The description provides no guidance on when to use this tool versus alternatives such as pbi_arrange_visuals or pbi_distribute_visuals. There is no mention of prerequisites, edge cases, or contexts where this tool is preferred, leaving the agent to guess which layout tool fits.

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

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

With no annotations, the description carries the full burden. It discloses that the tool 'detects' and 'reviews' specific model elements, suggesting a read-only analysis (since it says 'detecta' and 'revisa'). However, it does not state whether it makes changes, what the output looks like, whether a model must be loaded, or any side effects. It adds some value by listing the checks it performs, but leaves key behavioral traits undisclosed.

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

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

The description is concise, two sentences long, and each part adds information. The list of checks is dense but valuable, avoiding filler. It is front-loaded with the core purpose (detect model problems) and then elaborates with examples. No waste, though it could have been structured with more clarity around the parameter or usage.

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

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

The tool is a quality analysis with multiple checks, but the description does not explain the context: prerequisites, what the output schema provides (though it exists), or how this tool fits with sibling analysis tools. The parameter is unexplained, and there is no mention of whether a model must be open or what 'source' options exist. The list of issues gives some context, but overall completeness is lacking for a tool with one parameter and no annotations.

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 'source' with a default of 'live' and no description. The tool description does not mention the parameter at all, so the agent has no idea what values are valid or what 'source' refers to (e.g., live connection vs. file path). With 0% schema coverage and zero compensation in the description, the parameter is effectively unexplained.

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: detecting typical model quality problems. It lists specific issue categories (measures without folder, long DAX, relationships, calculated columns, visible IDs, missing calendar), giving a concrete sense of what it does. However, it does not explicitly differentiate from sibling tools like pbi_health_check or pbi_audit_model, so it lacks a clear comparative edge.

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 detecting model quality issues, but provides no explicit guidance on when to use it versus alternatives like pbi_health_check, pbi_audit_model, or pbi_model_summary. There are no prerequisites, exclusions, or context about the kind of situations where this tool is preferred, leaving 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?

With no annotations provided, the description fully carries the burden of behavioral disclosure. It reveals that each action is applied via a safe path with transaction, verification, and rollback, and that failures are reported without halting others and without hiding them. This is strong for a mutation tool, though it omits permission/scope details.

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 remarkably compact: one purpose sentence, one prerequisite sentence, and one behavior sentence. Every line adds value and there is 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?

Given the presence of an output schema, the description does not need to explain return values. It covers the core aspects: purpose, prerequisite, and error-handling behavior. A small gap remains around what happens if confirm=false or what request_id is used for, but overall it is well-rounded for a workflow-dependent tool.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that 'actions' should be the actions returned by pbi_plan_audit_fixes and that 'confirm' must be true for the operation to proceed. However, 'request_id' remains unexplained, leaving a minor 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 ('Aplica' / applies) and a precise resource ('las acciones devueltas por pbi_plan_audit_fixes' / the actions returned by pbi_plan_audit_fixes). This clearly differentiates the tool from siblings like pbi_plan_audit_fixes (planning) and other audit/list tools.

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

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

The description gives a clear prerequisite ('Requiere confirm=true') and implicitly establishes the workflow by referencing pbi_plan_audit_fixes as the source of actions. It does not explicitly state when not to use it or name alternatives, but the planning/apply pairing is evident from the sibling list.

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

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

With no annotations, the description carries the full burden. It discloses transactional atomicity, the four possible outcomes, preservation of page and visual IDs on update, the conservative default of merge mode (to prevent accidental deletion), and that dry_run writes nothing and returns a plan token. It does not mention permissions, conflict handling details, or side effects beyond the core behavior, but overall it is substantially transparent.

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

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

The description is well-structured with a lead sentence, a clear list of outcomes, and separate paragraphs for page, sync_mode, and dry_run. It is somewhat longer than necessary but every sentence adds value, and code formatting improves readability. It is front-loaded with the primary action and transactional guarantee.

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 (6 parameters, nested spec, multiple modes, and outcomes), the description covers the essential behavioral and workflow context. It explains the dry_run → pbi_apply_plan flow, which is crucial for safe usage. It omits details about seed and request_id, but those are likely auxiliary; an output schema exists, so return values are not needed in the description. Overall, it is sufficiently complete 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 coverage is 0%, so the description must compensate. It provides meaningful semantics for page (id or visible name, defaults to spec name, preserves IDs), sync_mode (merge vs replace with conservative default), and dry_run (plan token). However, the central 'spec' parameter is not explained beyond 'el spec', and 'seed' and 'request_id' are completely undefined. While the covered parameters are important, the most critical input lacks any structural guidance.

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

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

The description opens with a specific verb and resource: 'Materializa el spec como una pagina PBIR' (materialize the spec as a PBIR page), and adds a critical qualifier 'en UNA transaccion' (in one transaction). It further distinguishes itself from sibling tools like pbi_create_page_from_spec by listing four explicit outcomes (create, update, no_change, conflict), clarifying that it handles existing pages idempotently.

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: it applies a page spec to a PBIR page, with outcomes based on existence and change. It gives guidance on sync_mode (merge vs replace) and dry_run, explaining their purposes. However, it does not explicitly name alternative tools or say 'use this instead of X', so it misses the full when-not-to-use clarity.

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

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

With no annotations, the description carries the full burden. It discloses key behavioral traits: it verifies the project is in the planned state and rejects the plan if changed, preventing unintended changes. It also explains the optional expected_operation check and its failure mode (plan_operation_mismatch). This goes beyond a terse 'apply plan' and offers meaningful safety context.

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

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

The description is brief and front-loaded with the primary action, followed by the safety verification and optional parameter behavior. Every sentence contributes meaning, with 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 tool's complexity (applying a plan, safety checks) and no annotations, the description covers the essential aspects: purpose, safety checks, and one parameter detail. The output schema covers return values, so that omission is acceptable. However, missing explanations for confirm and request_id slightly reduce completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It only explains expected_operation, while plan_token, confirm, and request_id receive no semantic explanation. plan_token is implied by context, but confirm's behavior (e.g., what happens if false) and request_id's purpose are unclear. The description adds value for one parameter but leaves three under-documented.

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

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

The description clearly states the verb and resource: 'Aplica un plan calculado con pbi_plan_change o con un dry_run' (Applies a plan calculated with pbi_plan_change or with a dry_run). It differentiates from sibling tools like pbi_plan_change (which creates the plan) and pbi_apply_audit_fixes by explicitly referencing the plan origin.

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: use this after generating a plan via pbi_plan_change or dry_run. The description also mentions a safety check (rejects plan if project state changed), providing context for when it's safe to apply. However, it does not explicitly mention alternatives or exclusions.

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

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

The description discloses that visuals are reorganized and that by default all visuals are affected, plus the custom layout format. However, with no annotations, it fails to state whether changes are destructive, permanent, require specific permissions, or how spacing/canvas affect the outcome, which is significant for a mutation tool.

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

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

The description is brief and well-structured with backtick formatting for parameter explanations. It front-loads the main purpose and then lists the key params efficiently, without wasted words. It could be slightly more organized, but it earns its place.

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

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

Despite having an output schema, the description is incomplete for a 7-parameter tool. It does not explain the semantics of the required 'page' parameter, how 'spacing' is applied, what 'canvas' does, or the behavior of layout presets. Given similar sibling tools, more context is needed to correctly invoke the tool.

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

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

Schema description coverage is 0%, so the description must compensate. It adds useful semantics for three parameters (layout values, visual_ids subset, custom map structure), but it omits meaning for required 'page' and other params like 'canvas', 'spacing', and 'request_id'. The partial compensation keeps this at a mid score.

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+resource ('Reorganiza los visuales de una pagina') and mentions layout presets, making it clear it rearranges visuals on a page. However, it does not distinguish itself from similar sibling tools like pbi_align_visuals, pbi_distribute_visuals, or pbi_normalize_page_layout, so it lacks full differentiation.

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

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

No explicit guidance is given about when to use this tool versus alternatives. The mention of layout presets (grid, dashboard, executive_summary, custom) implies some use cases, but there is no stated context, prerequisites, or exclusions, leaving the decision to the agent without support.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds valuable context by stating that each finding includes evidence and that 'ninguna heuristica se presenta como certeza' (no heuristic is presented as certainty), which clarifies the epistemic nature of results. It does not mention side effects or permissions, but for an audit tool this is a meaningful 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 efficiently structured: a one-sentence purpose, a sentence detailing finding fields, a caveat about heuristics, and two parameter clarifications. Every sentence adds value with no redundancy or filler.

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

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

The description covers the output structure (rule, severity, object, evidence, recommendation, auto_fix_available), explains key parameters, and discloses the tool's epistemic limitations. It misses the `source` parameter, which is a gap, but the existence of an output schema reduces the need to describe return values in detail.

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

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

Since schema description coverage is 0%, the description must compensate. It explains that `rules` is a subset from pbi_list_audit_rules and enumerates possible values for `min_severity` (info | warning | error). However, it completely omits the `source` parameter, leaving it undefined in both schema and description.

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

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

The description clearly states 'Audita el modelo semantico' (audit the semantic model) with a specific verb and resource, and further specifies 'reglas de identificador estable' (stable identifier rules). It doesn't explicitly differentiate from sibling audit tools like pbi_audit_project or pbi_analyze_model_quality, so it falls short of full distinction.

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

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

The description implies usage for auditing semantic models with a subset of rules and a severity threshold, referencing pbi_list_audit_rules for rule selection. However, it provides no explicit guidance on when to choose this tool over overlapping siblings like pbi_audit_project or pbi_analyze_model_quality.

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

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

With no annotations, the description carries the behavioral burden. It transparently discloses that it returns a global/per-domain score, executive summary, prioritized findings with evidence and recommendations, and which rules support auto-correction. It also reveals the side-effect that specifying 'formats' as markdown/html writes report files to outputs/ and returns their paths. It does not explicitly state whether the audit modifies the project, but the audit framing plus the disclosed side-effect covers the most important behavioral traits.

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

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

The description is compact and front-loaded: a one-line summary, a list of key outputs, then parameter behavior. Every sentence adds value, and there is no redundant repetition of the tool name or 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 tool's moderate complexity and the presence of an output schema, the description adequately covers purpose, returned content, file-writing side-effects, and parameter scoping. It could be more complete by stating `min_severity` allowed values and explicit usage guidance relative to sibling audit tools, but it does not leave major functions unexplained.

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 `formats` with concrete allowed values ('markdown','html') and their side-effect, and notes that `rules` and `min_severity` constrain the audit. However, it does not clarify the accepted values for `min_severity` or the expected format/structure of `rules`, leaving some parameter semantics under-specified.

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 'Auditoria integral: modelo semantico + informe + layout', which specifically defines the tool as a comprehensive audit of a Power BI project covering three distinct areas. This clearly distinguishes it from siblings like pbi_audit_model (model only) and pbi_audit_report_only (report only). The verb 'Auditoria' plus the resource scope makes the purpose unmistakable.

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

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

The scope 'integral' communicates when to use this tool: when a full project-level audit spanning semantic model, report, and layout is needed. However, it does not explicitly name alternatives or give when-not-to-use guidance, so it lacks the explicit exclusion criteria needed for 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?

With no annotations, the description carries full burden. It discloses the specific checks performed (empty pages, visuals without title, broken fields, duplicates, inconsistent canvas sizes, page geometry), which is useful behavioral context. However, it does not state whether the tool is read-only, what it returns (though an output schema exists), or any side effects, leaving room for assumption.

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 concise sentences, front-loaded with the main scope and followed by a bullet-like list of coverage areas. Every word earns its place with no redundant filler.

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

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

Given that the tool has no parameters and an output schema exists, the description covers the essential scope and criteria well. It clearly defines what the audit covers and excludes, which is sufficient for an agent to invoke it appropriately. Minor omission: it does not describe the return format, but the output schema handles that.

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

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

The tool has zero parameters and schema coverage is 100%, so there are no parameter semantics to clarify. The baseline of 4 applies as the description does not need to compensate for missing parameter info.

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 'Audita solo el informe PBIR' (audits only the PBIR report), identifying the exact resource and action. It further distinguishes itself from sibling tools by explicitly excluding 'las reglas del modelo semantico' (semantic model rules), which differentiates it from pbi_audit_model and pbi_audit_project.

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 by stating it audits 'solo el informe PBIR' and explicitly excludes semantic model rules, implying when not to use this tool. It does not name alternatives or provide explicit when-to-use guidance, but the exclusion helps the agent choose correctly among sibling audit tools.

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

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

With no annotations, the description discloses that it creates a timestamped backup and returns the path. It does not elaborate on side effects, permissions, or preconditions, so it only partially covers behavioral transparency.

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, with the main purpose in one sentence and parameter options in a single line. Every word contributes, making it highly efficient and front-loaded.

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

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

For a simple tool with two optional parameters and an output schema, the description is largely sufficient. It explains the core behavior, parameter options, and return value. Minor gaps like prerequisite conditions (active project) are not mentioned.

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 zero description coverage, but the description enumerates the accepted values for both parameters ('folder | zip' and 'report | model | both') and notes the return value. However, it does not explain what each option means, leaving some ambiguity.

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 provides a specific verb ('Crea'), resource ('.pbip project'), and qualifiers ('con timestamp', 'activo'). It clearly distinguishes from sibling tools like pbi_purge_backups and pbi_recover_from_journal, making the tool's purpose unambiguous.

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

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

The description implies usage as a backup creation tool via context, but it does not explicitly state when to use it versus alternatives, nor does it mention exclusions or prerequisites such as requiring an open project.

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

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

With no annotations provided, the description carries the full burden and does disclose key behaviors: it outlines the workflow (analyze model, compose spec, calculate layout, generate preview, apply in transaction, verify) and importantly states that dry_run=true (default) stops after preview. This reveals the tool's safe-by-default execution mode but does not detail side effects of applying or what verification entails.

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

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

The description is two short paragraphs with no wasted words. The opening line is a crisp purpose statement, followed by a compact step list and a critical flag note. Every sentence adds value and the structure is front-loaded with the main purpose.

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

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

The tool is complex (6 parameters, multi-step workflow) with no annotations and an output schema that likely defines return values. The description provides a high-level workflow and dry_run behavior but omits essential details like how the 'objetivo' is expressed in parameters, what presets are available, and prerequisites such as requiring a selected model. It is a minimal viable description but has clear gaps for a tool of this complexity.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meanings. It only explains dry_run (default true, stops after preview), leaving name, measures, seed, preset, and category undefined. This is insufficient for an agent to know what values are expected or how they relate to the 'objetivo'.

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 it builds a complete dashboard from an objective, not from primitives, using the verb 'Construye' with a specific resource and scope. It distinguishes itself from sibling tools like pbi_build_executive_page or pbi_create_visual by emphasizing the high-level 'objetivo' approach.

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 clear context for when to use: when you have an objective rather than building from primitives. It also gives explicit guidance about dry_run default behavior, informing the agent it can preview before applying. However, it does not explicitly name alternative tools or state when not to use this tool.

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

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

With no annotations provided, the description carries the full burden of behavioral transparency. It discloses a key validation behavior: if the expected measures are not recognized, the tool warns instead of generating a meaningless page. This goes beyond the basic creation action and provides useful safety context, though it does not mention other behaviors like error handling, permissions, or output format.

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 that immediately state the purpose, then explain the validation behavior. Every word earns its place, and the key information is front-loaded. There is no fluff or repetition.

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

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

Given the tool has 5 parameters and no schema descriptions, a complete description would need to address all parameters or point to the output schema. The description effectively covers the core purpose and the key behavioral nuance, but it leaves name, seed, dry_run, and category unexplained. The output schema exists but does not help the agent understand parameter semantics, so the description is only minimally complete for a tool of this complexity.

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

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

The input schema has 0% description coverage for its 5 parameters, so the description must compensate. It adds meaning to the required 'measures' parameter by listing the expected types (PV, EV, AC, CPI, SPI), but it entirely ignores the other parameters (name, seed, dry_run, category). Thus, it only partially compensates for the lack of schema descriptions, leaving significant ambiguity for the agent.

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: building an EVM (Earned Value Management) page, and specifies the expected measure types (PV, EV, AC, CPI, SPI). The verb 'build' and resource 'EVM page' are specific and distinguish it from sibling page-building tools that target other types of pages.

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 this tool should be used (when creating an EVM page with relevant measures) and mentions a validation behavior (warns if measures are unrecognized). However, it does not explicitly state when not to use it or mention alternatives like pbi_build_executive_page or pbi_build_dashboard, leaving some ambiguity for an AI agent choosing among similar tools.

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

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

No annotations are provided, and the description fails to disclose whether this tool modifies existing pages, requires specific model context, or has side effects. It only describes the page composition (KPIs and chart), leaving behavioral expectations unclear.

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

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

The description is a single, concise sentence with no waste. However, it is under-specified; while efficient in length, it lacks the richness needed for a tool with multiple parameters and implied 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?

Given the tool's complexity (5 parameters, 1 required) and lack of annotations, the description is far too sparse. It does not mention the purpose, prerequisites, or the meaning of key parameters, making it insufficient 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?

With 0% schema description coverage, the description needed to explain parameters like seed, dry_run, category, and measures. It only hints that measures are used for KPIs, but leaves the other parameters completely unexplained.

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 indicates this tool creates an executive summary page containing a row of KPIs and a hero chart. Combined with the tool name 'pbi_build_executive_page', the purpose is evident. It does not explicitly differentiate from siblings like pbi_build_evm_page, but the specific page type sets it apart.

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

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

There is no guidance on when to use this tool versus alternatives such as pbi_build_evm_page or pbi_generate_report_page. The description only implies its use for executive summaries but does not state conditions or exclusions.

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

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

With no annotations, the description carries the burden of explaining behavior. It reveals this is an informational, read-only style query ('consultarla', 'dice si...') and details the specific categories of state it reports, such as live layer availability and .pbip write capability. It does not explicitly state 'does not modify anything,' but that is strongly implied and acceptable for a capabilities inspection 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 concise and front-loaded: the first line immediately conveys the tool's purpose, the second gives usage guidance, and the third adds specific covered capabilities. Every sentence earns its place, with 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 that this is a zero-parameter capability query with an output schema, the description covers all necessary context: what it reports, why it exists, and when to use it. The output schema handles return-value details, so the description is complete without being verbose.

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

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

The tool has zero parameters and the schema is empty, so the baseline is 4. No parameter explanation is needed because there is nothing to explain.

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 what the tool does: report what can and cannot be done right now, with reasons. It distinguishes itself from the many task-specific sibling tools by framing itself as a pre-planning capability check covering live layer availability, .pbip writability, and engine-version-dependent features. The verb and resource are specific and meaningful.

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 'Un agente debería consultarla antes de planificar' (an agent should consult it before planning), giving clear when-to-use context. It does not name alternatives or when not to use it, but the guidance is sufficient for a unique capability-introspection tool.

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

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

No annotations are provided, so the description carries the full burden. It discloses what dependencies are found (measures, calculated columns, relationships, hierarchies) and that it indicates if something breaks. However, it does not explicitly state whether the operation is read-only, nor does it describe the output format or behavior for edge cases. 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 two short sentences, front-loaded with the core function and immediately followed by the practical use case. Every word earns its place with no redundancy.

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

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

Given that an output schema exists, the description doesn't need to explain return values. It covers the main purpose, dependency types, and use case effectively. The only missing context is the meaning of the 'source' parameter and more explicit read-only behavior, but overall it is complete for a dependency-analysis 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 schema shows three parameters (table, column, source) with 0% schema coverage from the description. The description does not explain any parameter semantics, especially 'source' (which defaults to 'live'). Since the schema alone provides minimal context, the lack of parameter explanation is a notable 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 clearly states the tool's purpose: 'Que usa una columna: medidas, columnas calculadas, relaciones y jerarquias' (what uses a column: measures, calculated columns, relationships, and hierarchies). This is a specific verb+resource combination that distinguishes it from siblings like pbi_measure_dependencies (which focuses only on measures) and pbi_list_relationships (which focuses only on relationships).

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 provides usage context: 'Util antes de ocultar o eliminar una columna: dice si algo se rompe' (Use before hiding or deleting a column: it tells if something breaks). This clearly indicates when to use the tool, though it does not name alternatives or specify when not to use it.

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

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

With no annotations provided, the description carries the full burden. It discloses specific behaviors: listing tables and measures only on one side and measures with differing DAX, which gives concrete expectations beyond just 'compare'. It does not mention side effects, but as a comparison operation, none are implied.

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

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

The description is two short, focused sentences. The first sentence states the core action, and the second adds the use case and specific elements compared. No unnecessary words 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?

With an output schema present, the description need not explain return values. It covers purpose, usage, and behavioral detail, which is fully sufficient for a zero-parameter comparison tool. It is contextually complete for the agent to 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 tool has zero parameters, so the input schema is complete by default. The baseline of 4 applies, and the description adds meaning about what the tool operates on (live model vs TMDL), which is helpful even without 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 compares the live model with the TMDL on disk using the specific verb 'Compara' and naming both resources. This distinguishes it from sibling tools like validation or documentation tools, making its purpose unmistakable.

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

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

It explicitly says it is useful for detecting unsaved in-memory changes, providing a clear when-to-use context. However, it does not mention alternatives or when not to use it, so it falls short of full explicit guidelines.

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

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

No annotations are provided, so the description carries the burden. It discloses important behaviors: same-type-only restriction and that title text is not copied. However, it does not mention overwriting semantics, permissions, or failure modes beyond type mismatch, leaving gaps for a mutation tool.

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

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

Three short sentences, front-loaded with purpose, each providing distinct useful information: the core action, the title exclusion, and the type restriction rationale. No unnecessary 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 tool with 5 parameters and no annotations, the description is too thin on parameter semantics and side effects. It does not specify what 'format' includes, how success is reported (despite having an output schema, it is not provided), or prerequisites beyond type matching. The description needs more detail to be 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% and the description does not explain the parameters. It implies target_visuals must be same type as source, but it does not clarify how source_page/source_visual/target_visuals are identified or what request_id is for. The description fails to compensate 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 uses a specific verb ('Copia') and resource ('formato de un visual a otros DEL MISMO TIPO'), clearly distinguishing from sibling tools like duplicate_visual or set_visual_title. It precisely states the action and 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?

It states when to use (copying format between same-type visuals) and when-not (different types rejected, title not copied). However, it does not explicitly name alternative tools for copying titles or duplicating visuals, so it lacks the full alternative guidance for 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?

No annotations are present, so the description must carry the full burden. It discloses a side effect (registers custom visual) and a dependency (measure created separately). However, it does not address error conditions, overwrite behavior, or required permissions, leaving gaps for a mutation tool.

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

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

The description is brief and front-loaded with the core purpose, followed by a clarifying note about measure creation and DAX implementation. It is appropriately sized and every sentence contributes meaning, though the code example could be seen as slightly extra.

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

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

The description covers the main workflow and differentiation, but leaves critical details about `position` semantics and page targeting unspecified. With a 5-parameter schema, no annotations, and no schema descriptions, more context is needed to correctly invoke the tool without additional domain knowledge.

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 only elaborates on `html_measure`, giving an example format. It leaves `page`, `position`, `title`, and `request_id` unexplained; `position`'s nested structure is especially ambiguous. This is insufficient compensation for the coverage 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 clearly states it creates an 'HTML Content' visual that renders HTML/SVG returned by a measure, using a specific verb and resource. It also distinguishes this tool from generic creation tools like pbi_create_visual and pbi_add_custom_visual by focusing on the specific HTML Content visual type.

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

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

Provides workflow guidance by explicitly stating that the measure is created separately with pbi_create_measure and that the custom visual is registered if not already present. It implies this tool should be used specifically for HTML Content visuals, though it does not formally list alternatives or exclusions.

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

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

With no annotations, the description discloses validation (table exists, measure not exist unless overwrite), the diff return, and the mode constraints requiring Desktop open/closed. It does not mention permission requirements or broader side effects, but the core behavioral traits are covered.

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 paragraph with each sentence providing distinct information: purpose, validation, optional data_category, diff output, and mode restriction. No filler or repetition; front-loaded with the main action.

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

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

Given the 10-parameter schema and mode complexities, the description covers the key aspects: validation, overwrite behavior, mode selection, and data_category example. It also mentions the diff return, complementing the output schema. It could mention error cases or prerequisites, but overall it's sufficient for an agent to invoke correctly.

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

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

Schema coverage is 0%, so the description must compensate. It adds meaning for data_category (with ImageUrl example), mode (disabling both), and overwrite (replacement), but leaves format_string, display_folder, and other parameters unexplained. Still, the core parameters are obvious from the schema titles, so the added semantics is moderately 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 opens with 'Crea (o reemplaza con overwrite=true) una medida DAX', clearly stating it creates or replaces a DAX measure. It also specifies validation behavior and naturally differentiates from update/delete siblings by focusing on creation with overwrite semantics.

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

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

It provides explicit usage context for the mode parameter: 'Elige live o pbip' and explains why mode='both' is disabled. It also clarifies when overwrite=true is relevant, but does not explicitly name alternative tools like pbi_update_measure for comparisons.

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

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

With no annotations, the description carries the behavioral disclosure burden. It provides useful specifics: 'Clona visuales existentes del mismo tipo como plantilla', 'Hace backup', and explains that omitting 'position' lets the visual auto-arrange based on 'layout'. This goes beyond the tool name, though it lacks details on overwrite behavior or permissions.

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 information-dense: a one-line purpose, a code-block spec shape, and two behavior side-notes. Every sentence contributes, there is no filler, and the core purpose is front-loaded.

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

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

The tool is moderately complex with a nested spec object and no annotations, and the description does cover the spec structure and key side effects (clone, backup, auto-layout). However, it doesn't mention how to choose this over related page-spec tools, lacks error/prerequisite context, and the semantics of fields/refs is under-specified. The presence of an output schema reduces the need for return-type documentation, so the description is 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?

The schema offers almost no parameter documentation (0% coverage, spec is additionalProperties), so the description compensates with a detailed inline spec: page_name, canvas?, layout?, visuals with type/title/fields/position. It also clarifies a key behavior ('Omite position... auto-acomode'). Slight ambiguity in 'rol:refs' and no full example prevent a 5.

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

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

The description clearly states it creates a complete PBIR page from a spec: 'Crea una hoja (pagina) PBIR completa a partir de un spec.' It uses a specific verb and resource, and the inline spec summarized with layout types (grid|dashboard|executive_summary) and visual structure distinguishes it from generic page tools.

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

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

The description implies usage when you have a structured spec and want a fully fleshed-out page, and notes cloning/backup behavior. However, it doesn't explicitly explain when to use this tool over siblings like pbi_apply_page_spec, pbi_compose_page, or pbi_generate_page_spec, and offers no exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the full burden. It discloses notable behavior: 'Clona un visual del mismo tipo como plantilla si existe. Hace backup.' (Clones a visual of the same type as a template if it exists, backs up). This adds non-obvious context, but it does not explain other potential side effects, prerequisites, or failure modes, leaving gaps.

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

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

The description is concise and well-structured: a clear opening sentence, followed by parameter definitions in code-style formatting. It adds no fluff; every line serves a purpose. The cloning and backup note is included efficiently at the end.

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 nested objects and an output schema, so return values are handled. However, the description lacks contextual completeness in terms of when to use this tool relative to other visual-creation or duplication tools, and does not mention any dependencies or conditions (e.g., page must exist). It is adequate but not thorough for a tool with many visual-related siblings.

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

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

Schema coverage is 0%, so the description must compensate. It provides concise but valuable parameter documentation for visual_type, fields, and position, including allowed values and structure examples. However, it does not explain 'page', 'title', or 'request_id', though these are relatively self-explanatory. This significantly exceeds the schema's bare type definitions.

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

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

The description starts with a clear statement: 'Crea un visual PBIR en una pagina' (Creates a PBIR visual on a page). This specifies the action (create), resource (visual), and context (on a page), distinguishing it from sibling tools like pbi_create_html_visual or pbi_duplicate_visual.

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 pbi_duplicate_visual or pbi_create_html_visual. The description only states what it does and provides parameter examples; it does not mention conditions, prerequisites, or exclusions.

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

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

With no annotations provided, the description carries the full burden. It discloses the destructive nature, the mandatory confirm flag, and the mode-specific behavior, including why 'both' is disabled due to conflicting Desktop state requirements. This is valuable context beyond the bare schema, though it doesn't mention dependency impacts or reversibility.

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 brief and front-loaded with the main purpose. The first sentence is very concise, and the following sentences provide essential warnings and usage details. The second sentence is slightly long but packs necessary information without unnecessary 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?

Given the destructive nature and absence of annotations, the description covers the most critical aspects: confirmation requirement, mode selection rules, and the temporary 'both' restriction. The presence of an output schema handles return value expectations. It lacks some details about prerequisites or side effects, but the core usage is well specified.

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 for parameters. The description adds meaning to 'confirm' (must be true) and 'mode' (choose 'live' or 'pbip', with 'both' disabled), which is critical. However, 'table', 'name', and 'request_id' remain unexplained, relying on their self-evident names. Partial compensation only.

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 'Elimina una medida' (deletes a measure), specifying the verb and resource. It also marks the operation as destructive, distinguishing it from non-destructive measure-related tools like pbi_create_measure or pbi_update_measure.

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

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

The description provides explicit usage guidelines: the operation requires confirm=true, and mode='both' is temporarily disabled, with instructions to choose either 'live' or 'pbip'. It explains the operational constraints (Power BI Desktop open/closed) but does not discuss alternative tools or when not to use this tool.

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

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

With no annotations, the description carries the full burden. It discloses that the operation is destructive, requires confirm=true, and will refuse to delete the last page because a report without pages cannot open. It also notes it updates page order and active page, which are useful side-effect behaviors.

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 brief and front-loaded with the main action. Every sentence adds value: the operation, its side effects, safety requirements, and a key edge case. No wasted words.

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

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

For a destructive tool with an output schema, the description provides enough context: the action, confirmation requirement, and edge case protection. It does not detail the output, but that is covered by the output schema. It could mention the behavior when confirm is false, but overall it is sufficiently complete.

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

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

Schema coverage is 0%, so the description must compensate. It explains the confirm parameter's role ('requiere confirm=true') and implies the 'page' parameter is the page to delete, but it does not clarify the format of 'page' or mention 'request_id'. This partial compensation earns a 3.

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

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

The description clearly states the verb 'Elimina' (deletes) and the resource 'una pagina' (a page), and also mentions it updates the order and active page. This distinguishes it from related sibling tools like pbi_duplicate_page or pbi_rename_page.

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: it is destructive and requires confirm=true, and it refuses to delete the last page. However, it does not explicitly mention alternative tools or scenarios when not to use this tool, so it falls short of 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?

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly discloses that the operation is destructive, requires confirmation, returns the previous definition, and is recoverable via the journal. This goes well beyond a simple 'delete' and gives the agent a clear safety picture.

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

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

The description is two short sentences, front-loaded with the primary action and the key destructive requirement. It also includes recoverability information, earning its place 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?

For a destructive operation with no annotations, the description covers the essential context—destructiveness, confirmation, return of prior definition, and restorability. The presence of an output schema reduces the need to detail return values, though it could be more explicit about prerequisites or side effects.

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

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

The schema has 0% description coverage, so the description must compensate. It explains the confirm parameter's necessity but does not clarify page, visual_id, or request_id beyond their titles. This leaves the agent to infer the purpose and format of most 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 'Elimina un visual' (deletes a visual), using a specific verb and resource. This distinguishes it from sibling tools like pbi_get_visual or pbi_create_visual. The destructive nature is also emphasized.

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 deleting a visual, but does not explicitly state when to use it over alternatives or exclude other situations. It does provide a critical usage requirement—confirm=true is required—but lacks explicit 'when not to use' guidance.

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

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

With no annotations provided, the description carries the full burden. It explicitly discloses read-only behavior and the nature of findings (each finding includes geometric evidence), providing transparency about what the tool does and returns.

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, using two short sentences to convey purpose, read-only nature, detected issues, and output evidence. No superfluous content.

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

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

Given that an output schema exists, the description sufficiently explains what issues are detected and that evidence is provided. It could be more explicit about scope or prerequisites, but for a read-only diagnostic tool it is adequately complete.

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

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

The description adds meaning to the `page` parameter by indicating it can target a specific page or all pages when omitted, which clarifies the null default. However, it does not specify the expected format of the page identifier, and schema coverage is 0%.

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

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

The description clearly identifies the tool as diagnosing page geometry, listing specific issues it detects (overlaps, off-canvas visuals, sizes, margins, spacing, Z-order, empty/saturated pages). It explicitly states 'Solo lectura' (read-only), distinguishing it from sibling tools that modify or document layout.

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 diagnosing layout issues before editing, and notes the read-only nature, but it does not explicitly state when to use this tool over alternatives like pbi_normalize_page_layout or pbi_document_report_layout. The context is clear but exclusions are not 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?

With no annotations, the description carries full responsibility. It clearly discloses that the tool is non-destructive (comparison only), what it reports (added/leftover/unchanged visuals), and how it handles a missing page. This provides complete transparency for an agent to predict tool 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 concise (three short sentences) and front-loaded with the primary purpose. Every sentence adds value: what the tool does, what it reports, and edge-case behavior. No wasted words.

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

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

Given the simple tool, the description covers the essential behavior and edge case. An output schema exists, so not detailing return values is acceptable. It could mention the format of 'page' or 'spec' but is complete enough for an agent to use 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 has 0% description coverage, so the description must clarify parameters. It implicitly defines 'spec' as the new specification and 'page' as the existing page, but doesn't explain the spec structure or page identifier format. The default null for page is not addressed, leaving some ambiguity.

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: comparing a spec against an existing page before applying it. It specifies the outputs (added visuals, leftover visuals, count unchanged) and the behavior for non-existent pages, distinguishing it from sibling tools like apply or validate.

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

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

The phrase 'before applying it' implies usage as a pre-application check, distinguishing it from pbi_apply_page_spec. It provides context for when to use the tool, though it doesn't explicitly list alternatives or exclusions. The edge case of a missing page is addressed, giving practical 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?

With no annotations, the description carries the burden of behavior disclosure. It explains what happens when deactivating (Power BI removes automatic date tables on reopen) and states the prerequisite (active .pbip project). It does not, however, describe the effect of enabling or any side effects beyond the removal of tables.

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 and well-structured, with the action in the first sentence and supporting details in the second. Every sentence adds value and there is no redundancy or filler.

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

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

The tool is a simple toggle and the description covers its core behavior, prerequisites, and consequences of deactivation. However, the lack of parameter explanation and the absence of detail about activation leave it slightly incomplete. The presence of an output schema reduces the need to describe return values.

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 two parameters with 0% coverage, and the description does not explain how the 'enabled' boolean maps to activating/deactivating or what 'request_id' is for. The description adds no value to understanding the parameters, which is a significant gap given the schema provides no descriptions.

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

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

The description clearly states the tool's function: 'Activa/desactiva Auto fecha y hora' (activates/deactivates auto date/time), and specifies the scope with 'solo modo pbip'. This distinguishes it from other tools and immediately conveys the action on a specific resource.

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: it is pbip-only and requires an active .pbip project. It also implies a use case by explaining that deactivating lightens the model, which gives a reason to use it. However, it doesn't explicitly mention alternatives or when not to use it.

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

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

No annotations are provided, so the description carries the full burden. It discloses a behavioral edge case (with two visuals, no change occurs) and defines `axis` values, but it does not state that the tool modifies visual positions, what exactly 'separacion uniforme' implies (e.g., equal gaps), whether it respects page boundaries, or whether it is destructive. This is partial disclosure, leaving significant behavioral context unstated.

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 only two short sentences. It front-loads the core action and immediately covers the `axis` parameter, then adds a useful caveat about the minimum number of visuals. Every sentence earns its place, with no repetition 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?

This is a layout-mutation tool with no annotations, a sparse schema, and a minimal description. It provides the three-visual minimum and axis values but lacks essential operational context: what visual_ids represents, what page is needed, what side effects occur (e.g., position changes), and how it differs from sibling layout tools. The presence of an output schema does not compensate for these gaps, making the tool under-specified for an agent to use confidently.

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 0% description coverage, so the description must compensate. It explains `axis` with allowed values ('horizontal|vertical'), but the other three parameters (page, visual_ids, request_id) are not addressed. Critically, visual_ids—the list of visuals to be distributed—is left unexplained, making it hard for an agent to know what to pass. The description only adds value for one of four 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: 'Reparte visuales con separacion uniforme' (distributes visuals with uniform separation), which is a specific verb+resource pair with a clear outcome. It also explains the `axis` parameter, but it does not explicitly distinguish itself from sibling tools like pbi_align_visuals or pbi_arrange_visuals, so it falls short of full differentiation.

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

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

The description provides a clear prerequisite: 'Necesita al menos tres visuales: con dos, la separacion ya es la que hay' (needs at least three visuals; with two, the separation is already the existing one). This tells the user when the tool has no effect, but it does not mention alternative tools or when to prefer this over align/arrange. Usage is implied rather than explicitly contrasted.

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

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

With no annotations provided, the description discloses a key side effect: it saves the file to 'outputs/'. It also lists what the documentation includes. However, it does not explain the behavior of the 'source' parameter, overwrite policy, or whether the operation modifies the model. The write location is disclosed, but other behavioral aspects are missing.

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 short sentences, front-loaded with the main purpose, followed by content specifics and output location. Every sentence adds value with no redundancy or filler.

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

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

The tool has an output schema, so return values are likely covered there. However, the description omits the meaning of the 'source' parameter and does not position the tool relative to other documentation/analysis siblings. It provides a good high-level overview but leaves gaps that matter for correct use.

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 for parameters. The description only indirectly mentions 'include_quality' via 'advertencias de calidad' and does not explain the 'source' parameter at all. With two undocumented parameters, the description fails to compensate for the lack of schema metadata.

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 with a specific verb and resource: 'Genera documentacion completa del modelo en Markdown.' It enumerates the contents (tablas, columnas, medidas, relaciones, jerarquias, roles RLS, advertencias de calidad), which distinguishes it from narrower sibling tools like pbi_model_summary or pbi_list_relationships.

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 generating complete documentation, but it does not provide explicit guidance on when to use it instead of alternatives like pbi_generate_technical_documentation or individual listing tools. No exclusions or alternative comparisons are given, leaving usage context to inference.

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

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

No hay anotaciones, por lo que la descripción debe revelar el comportamiento. Solo indica que genera documentación, pero no aclara si es una operación de solo lectura, si modifica archivos, si requiere permisos especiales, o el formato exacto de salida más allá de Markdown. La información es mínima y no añade contexto sobre efectos secundarios o limitaciones.

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?

La descripción es una sola oración clara y directa, sin información redundante. El término 'Markdown' aparece al inicio, lo que facilita una lectura rápida y la identificación del formato de salida.

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?

Para una herramienta sin parámetros, la descripción cubre el propósito y el formato de salida de manera suficiente. Sin embargo, al existir múltiples herramientas de documentación entre los hermanos, carece de contexto sobre su diferencia específica (por ejemplo, que se enfoca en el layout y no en el modelo). El esquema de salida existe pero no se detalla, aunque para una operación simple la información es adecuada.

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?

El esquema no tiene parámetros, por lo que la descripción no necesita explicar parámetros. El baseline para 0 parámetros es 4; la descripción añade el alcance (páginas y visuales) que orienta al agente sobre el ámbito de documentación, compensando la ausencia de estructura.

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?

La descripción utiliza un verbo específico 'Genera documentacion Markdown' y especifica el recurso 'layout del informe (paginas y visuales)', lo que la distingue claramente de herramientas como pbi_document_model o pbi_list_visuals. El alcance es preciso y delimita el tipo de documentación generada.

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 se proporciona ninguna indicación sobre cuándo usar esta herramienta frente a alternativas como pbi_generate_technical_documentation, pbi_document_model o pbi_list_report_pages/pbi_list_visuals. Tampoco se mencionan exclusiones, prerrequisitos o contexto de uso.

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

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

No hay anotaciones, así que la descripción asume la carga. Explica que 'se regeneran los identificadores que deben ser unicos', revelando efectos secundarios importantes, y menciona atomicidad con 'en una sola transaccion'. Esto proporciona contexto relevante sin contradecir campos estructurados.

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?

La descripción es breve, directa y comienza con la acción principal. La segunda oración añade detalle relevante sobre identificadores sin divagar. No incluye información redundante.

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?

El tool es simple y la descripción cubre la operación central y efectos secundarios. Sin embargo, carece de detalles sobre los parámetros y no ofrece guía de uso o requisitos previos. La existencia de un output schema mitiga la necesidad de explicar el retorno, pero persisten vacíos.

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?

La descripción no menciona los parámetros 'page', 'new_name' ni 'request_id'. La cobertura del schema es 0%, y el único indicio semántico es el título 'New Name', pero no se especifica el formato del identificador de página ni el propósito de 'request_id'. No compensa la falta de descripción en el 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?

La descripción comienza con 'Duplica una pagina con todos sus visuales', indicando claramente el verbo y el recurso. Se distingue de pbi_duplicate_visual, ya que opera a nivel de página completa, y añade alcance con 'en una sola transaccion'.

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?

La descripción no indica explícitamente cuándo usar esta herramienta frente a alternativas como pbi_create_page_from_spec o pbi_duplicate_visual. El contexto de uso se deduce del propósito, pero no hay exclusiones ni escenarios recomendados.

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

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

No annotations are provided, so the description carries the full burden. It discloses that only the identifier is regenerated, the copy is offset to avoid overlapping, and target_page allows copying to another page. This adds meaningful behavioral context, though it omits details about permissions, error handling, or interactions.

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 short, focused sentences. Each sentence adds unique information: purpose, identifier regeneration, offset behavior, and target_page. No redundancy or fluff.

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

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

The description covers core behavior and key parameters, and an output schema exists to explain return values. However, with no annotations and 7 parameters, the lack of new_title/request_id explanations and absence of usage prerequisites make it incomplete for fully informed 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 offset_x/offset_y and target_page, but does not cover new_title or request_id. Page and visual_id are implied but not explicitly described. This partial coverage leaves some parameters under-explained.

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 'Duplica un visual conservando campos, formato y filtros', clearly stating the action (duplicate) and resource (visual), and specifies preserved attributes. This distinguishes it from siblings like pbi_delete_visual or pbi_copy_visual_format.

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

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

The description implies when to use the tool (to duplicate a visual with preserved properties) and provides context about offsets and target_page, but does not explicitly mention alternatives such as pbi_create_visual or pbi_copy_visual_format, nor any exclusions or when not to use it.

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

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

No annotations are present, so the description bears full responsibility. It discloses the output content (layout + visual fields) and that the page must exist, but does not clarify whether 'export' returns an HTML string, writes a file, requires an open project, or has any 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?

One concise, front-loaded sentence with a parenthetical clarification. No wasted words.

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

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

The tool has one parameter with no schema description and no annotations, and the description does not compensate by explaining parameter format or usage. Although the output schema exists, the input side remains under-specified, and the presence of many sibling page-related tools makes the missing usage guidance more costly.

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%, leaving the single 'page' parameter undocumented. The description only says the page must be 'existing,' giving a vague hint that it identifies a current page, but it does not specify whether the value is a name, ID, or page number.

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

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

The description clearly states a specific action (export), a specific output (HTML mockup), and the target resource (existing page), with a parenthetical defining scope (layout + fields of each visual). It distinguishes from sibling tools that preview or generate specs by emphasizing 'existing page.'

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 when-to-use guidance or alternatives are provided. The phrase 'existing page' implies use for current pages rather than creating new ones, but no explicit exclusions or references to related tools such as pbi_list_report_pages or pbi_preview_spec_html.

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

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

With no annotations, the description must disclose behavioral traits. It states that the output is an editable draft spec and should be validated, implying it is non-destructive and not directly applied. However, it does not explicitly mention side effects, permissions, or what happens to the generated spec beyond returning it. Some behavioral context is provided, but not exhaustive.

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 and well-structured: a one-sentence purpose, a bullet list of parameter meanings, and a closing instruction. It is front-loaded with the core purpose and uses minimal words to convey the workflow.

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

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

The tool has an output schema, so return values need not be explained. The description gives enough context for an agent to know this generates a draft spec that needs validation, and the parameter list covers the key customization options. However, it could more explicitly differentiate from other page-generation siblings and mention the page_name requirement, though overall it is sufficient for a low-risk generation 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 description explains the meanings of `preset`, `measures`, and `category`, which are the domain-specific parameters. However, the required `page_name` and `width`/`height` are not explained, though their names and defaults make them somewhat self-evident. Since schema coverage is 0%, the description partially compensates but leaves gaps.

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: 'Genera un borrador de spec a partir de un preset y unos campos' (generates a draft spec from a preset and fields). It also enumerates available presets, making the purpose specific. However, it does not explicitly distinguish from sibling tools like pbi_build_executive_page or pbi_generate_report_page, though the focus on a draft/editable spec implies a unique role.

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

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

The description provides a clear workflow: generate an editable spec, review it, and pass it through pbi_validate_page_spec. This gives when-to-use context. It does not explicitly mention alternatives or when not to use, but the validation step implies the intended lifecycle.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It transparently outlines the workflow: reviewing the model, validating fields (explicitly stating it does not invent fields), adding cards and charts, arranging the layout, and returning a summary. This adds valuable context beyond the schema, though it omits side effects like whether it overwrites an existing page or how 'create_missing_measures' affects 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 concise and well-structured. The first sentence states the main purpose, followed by a clear step-by-step breakdown, and ends with the return value. Every sentence earns its place, and there is no filler or repetition.

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

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

For a complex 6-parameter tool with an output schema, the description gives a solid high-level overview but lacks operational context: it doesn't mention prerequisites (e.g., an open project or selected model), what happens if the page already exists, or the meaning of 'objective' and 'request_id'. The output schema covers return details, but the description could still be more 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. It partially does by referencing 'layout indicado' (layout), 'campos sugeridos' (available_fields_hint), and 'medidas' (related to measures), but it does not explain 'objective', 'request_id', or clarify that 'create_missing_measures' controls whether missing measures are created. This leaves several parameters semantically under-specified.

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 generates a page with proposed visuals from the model, using a specific verb and resource. It includes the key action of creating a page and adding visual elements. However, it does not explicitly distinguish itself from sibling tools like 'pbi_create_page_from_spec' or 'pbi_compose_page', so it misses the 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?

The description explains what the tool does but provides no guidance on when to use it versus the many alternative page-creation tools (e.g., pbi_create_page_from_spec, pbi_generate_page_spec, pbi_apply_page_spec). There is no mention of prerequisites, exclusions, or comparison to alternatives, leaving the agent without clear decision support.

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

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

With no annotations, the description carries the full burden and discloses key behavior: output format (Markdown), destination (outputs/), and the three content areas it includes. It does not mention overwrite behavior or prerequisites, but for a zero-parameter generation tool this is reasonably transparent.

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

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

Two concise sentences with a clear bullet-style list of deliverables. Every sentence adds content value with no filler or repetition.

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

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

Given zero parameters and the presence of an output schema, the description adequately covers the tool's purpose and deliverable. It could mention prerequisites or error conditions, but the core scope is complete.

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

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

There are zero parameters, so the baseline of 4 applies. The description appropriately focuses on the generated output's contents rather than input 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?

Clearly states it generates complete technical documentation in Markdown saved to outputs/, and enumerates the included content: model, report, and audit. This differentiates it from narrower siblings like pbi_document_model and pbi_audit_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 implies use when comprehensive documentation across model, report, and audit is needed, but it does not explicitly state when to prefer this over focused tools like pbi_document_model or pbi_audit_project. No exclusions or alternatives are mentioned.

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

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

With no annotations, the description carries the transparency burden. It discloses that measures include DAX references and how column names should be formatted. It does not explicitly state side effects or error behavior, but the 'returns' verb implies a read-only operation.

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

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

The description is brief and front-loaded with the main purpose, followed by concise parameter guidance. Every sentence adds useful information, with no waste 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 is relatively simple and an output schema exists, so return details are covered. However, the missing explanation of the 'source' parameter and the absence of usage guidance relative to alternative tools leave the description incomplete for fully informed selection and 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 the 'kind' values and the name format for columns, but it completely omits the 'source' parameter, leaving its meaning and use unclear. Thus the description adds partial value over the schema.

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

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

The description clearly states it returns a model object with full detail, and it specifies the admissible kinds (table, column, measure). This makes the purpose understandable, though it does not explicitly contrast with sibling list/dependency tools.

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

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

The description provides practical guidance on how to specify columns ('Tabla[Columna]') and notes that measures include their DAX references. However, it does not mention when to prefer this tool over alternatives like listing tools or dependency tools.

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

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

With no annotations, the description carries the responsibility for disclosing behavior. It explicitly lists all return fields and includes the raw definition for inspection, making the read-only nature clear through the verb 'Devuelve' (returns). However, it does not explicitly state that it has no side effects or discuss error conditions, though the getter nature makes mutation unlikely.

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 long, with the first sentence stating the purpose and the second listing the returned data. It is concise, well-structured, and free of unnecessary detail.

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

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

The description thoroughly enumerates the output, which is appropriate for a getter tool, and the presence of an output schema reduces the need to explain return values. However, it lacks information about required context (e.g., an open project) and when to use this tool over related siblings, making it slightly incomplete.

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

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

Schema description coverage is 0%, and the description does not explain the meaning or format of 'page' and 'visual_id' beyond their names. While the names are somewhat self-explanatory, no additional context is provided, such as whether 'page' is a page name or ID, or how to obtain 'visual_id'.

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

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

The description clearly states this tool returns a complete normalized definition of a visual, enumerating specific attributes like type, position, Z-order, title, fields, filters, and raw definition. This distinguishes it from siblings such as pbi_list_visuals (which lists visuals) or pbi_get_object (a generic getter).

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 like pbi_get_object or pbi_list_visuals. It does not mention prerequisites, exclusions, or alternative tools, leaving the agent to infer usage from the tool name alone.

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

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

No annotations were provided, so the description carries the full burden. It discloses 'Solo lectura' (read-only) and enumerates the specific checks performed (dependencies, DLLs, session, project, live layer, pending journals). This provides meaningful behavioral context beyond a bare tool name, though it does not describe return format or error behavior (covered by output schema).

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

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

The description is compact and front-loaded. The first line states the core purpose, the second line adds read-only and usage priority, and the third line details what it reports. Every sentence adds value 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?

For a zero-parameter read-only health check tool, the description is complete: it covers purpose, usage timing, and the specific health signals it returns. The existence of an output schema covers return value details, so the description needs no further elaboration.

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

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

The tool has zero parameters and schema coverage is 100% (vacuously). With no parameters to document, the baseline is 4. The description does not need to add parameter semantics, and it doesn't.

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 'Estado general del servidor: dependencias, DLLs, sesion y proyecto', clearly stating the tool's purpose as a server health check. It further specifies what it reports (live layer availability, open .pbip project, items needing attention), distinguishing it from more focused siblings like pbi_session_info.

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

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

Explicitly states 'Es lo primero que conviene llamar' (It's the first thing to call), giving clear guidance on when to use it. It also explains what it tells the user, but it does not list alternatives or explicit when-not-to-use scenarios, so it stops short of 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?

With no annotations, the description carries full disclosure. It details validation before write ('Valida todas las entradas antes de escribir: si alguna tabla o columna no existe, no se modifica nada'), atomicity ('TMDL se escriben en una sola transaccion y el modelo en vivo con un solo SaveChanges'), and result semantics ('count' incluye duplicados, 'results' en el mismo orden). It also discloses the temporary mode='both' restriction and why.

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 purpose. Each subsequent sentence adds necessary detail (validation, transaction, mode caveat) without fluff. The structure is logical: purpose, parameter format, behavior, mode restriction.

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

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

Given no annotations and 0% schema coverage, the description covers most key aspects: batch operation, validation, atomicity, mode restrictions, and result counts. It is missing semantics for 'hidden' and 'request_id', but the provided details are comprehensive for a moderately complex tool with an output schema present.

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

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

Schema coverage is 0%, so the description must compensate. It explains the 'columns' structure ('lista de {"table": ..., "column": ...}') and the mode constraints ('Elige live o pbip'). However, it does not explain the 'hidden' or 'request_id' parameters, which are not self-evident from schema alone.

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

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

The description opens with 'Oculta/muestra VARIAS columnas como un solo lote' (Hide/show SEVERAL columns as a single batch), which clearly states the verb, resource, and batch scope. This distinguishes it from the sibling tool pbi_set_column_visibility, which likely handles single columns.

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

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

The description explains the batch use case ('VARIAS columnas como un solo lote') and provides explicit guidance on mode selection: 'la politica estricta: 'live' necesita Power BI Desktop abierto y 'pbip' lo necesita cerrado... Elige 'live' o 'pbip'.' It does not explicitly name alternatives like pbi_set_column_visibility, but the batch 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?

With no annotations, the description carries the full burden. It transparently states the tool is read-only and details what it reports for each file (original state, backup availability, outcome). This sufficiently discloses behavior, though it doesn't discuss error cases or permissions.

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 brief and well-structured, with a clear purpose statement followed by behavioral details and parameter guidance. No redundant info.

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

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

The tool has an output schema, so return values are covered. The description provides purpose, behavior, and parameter sourcing, making it sufficient for a simple read-only tool with one parameter.

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 a name and type for the journal parameter. The description adds valuable meaning by specifying it should be a path returned by pbi_list_pending_journals, eliminating ambiguity about the expected value.

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

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

The description clearly states the tool inspects a journal and compares it to the current project state, using a specific verb ('Inspecciona') and resource. It also distinguishes itself from recovery tools by explicitly stating 'Solo lectura: no restaura nada'.

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: it is read-only and does not restore, implying it should be used for inspection before any recovery. It also references pbi_list_pending_journals for obtaining the journal path, giving a concrete workflow. However, it does not explicitly name alternative tools or when not to use it.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only states it is a catalog, but does not explicitly say it is a read-only operation, whether it requires a model connection, or any side effects. The description adds minimal behavioral context beyond the tool's name.

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

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

The description is a single, concise sentence in Spanish that directly states the tool's purpose. It contains no extraneous information and is front-loaded with the essential content.

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

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

For a simple 0-argument list tool with an output schema, the description is adequate: it tells the agent that the tool lists audit rules with domain and severity. It could be more complete by hinting at the relationship to audit execution tools, but given the low complexity and existing schema, it is sufficient.

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

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

The tool has 0 parameters, and the schema coverage is vacuously 100%. Per the rubric, 0 params earns a baseline of 4. The description adds no parameter details because none are needed.

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

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

The description clearly states a specific verb+resource: it catalogs available audit rules, specifying the content (domain and severity). This distinguishes it from sibling tools like pbi_audit_model (which runs audits) and pbi_list_autofix_rules (which lists autofix rules, not audit rules).

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 by saying 'available audit rules,' suggesting it is meant to be consulted before applying audits. However, it does not explicitly state when to use it vs alternatives, nor does it provide exclusions or connections to audit workflow tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not mention whether the operation is read-only, whether there are side effects, or what the output format resembles. For a list tool, it lacks explicit behavioral context beyond implying the return of rule details.

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

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

The description is a single concise sentence in Spanish with no wasted words. It is appropriately brief but could be more explicit about the action, slightly reducing structural clarity.

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

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

The tool is simple with no parameters and an output schema, so the description covers the core content. However, it lacks usage guidelines and explicit behavioral notes, making it minimally complete for a list tool.

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

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

The tool has zero parameters, so the schema provides no parameter information. The baseline for 0 parameters is 4, and the description does not need to compensate for missing parameter documentation.

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

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

The description identifies the resource as rules with automatic correction and specifies that it covers what each rule consists of. However, it lacks an explicit action verb like 'list' or 'returns', leaving the tool's operation vague. It does not explicitly differentiate from sibling tools like pbi_list_audit_rules beyond the 'autofix' modifier.

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

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

No guidance is provided on when to use this tool versus alternatives such as pbi_list_audit_rules or pbi_apply_audit_fixes. The description only states the content, not the context or purpose for invoking the tool.

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

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

No annotations are provided, so the description carries the transparency burden. It discloses that the tool detects the Analysis Services engine for each open report and returns specific fields, using non-mutating verbs like 'Lista' and 'Detecta' that imply a read-only operation. It does not explicitly state 'does not modify anything', but for a list/discovery tool this is adequate.

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 and front-loaded: the first sentence states the core function, and the second adds the key output details without filler. It is appropriately sized for a simple list/discovery tool.

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

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

Given the tool's simplicity, zero parameters, and presence of an output schema, the description is complete enough: it explains what is listed, how discovery works, and what the return includes. A minor gap is not explicitly stating that Power BI Desktop must be running, though 'abiertos localmente' conveys this context.

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

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

The tool has zero parameters and an empty input schema, so there are no parameter semantics for the description to add. The baseline of 4 applies because the description cannot add value beyond the schema when there are no 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 purpose with a specific verb ('Lista') and resource ('modelos de Power BI Desktop abiertos localmente'), then adds useful output detail: it detects the Analysis Services engine on localhost:<port> and returns port, connection string, catalog, and table count. This distinguishes it from siblings like pbi_model_summary or pbi_select_model by emphasizing local open desktop 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?

The description gives a clear scope ('abiertos localmente') but does not explicitly say when to use this tool over alternatives such as pbi_list_tables, pbi_model_summary, or pbi_select_model. It does not mention exclusions or provide explicit when-to-use/when-not-to-use guidance, so the usage context is only 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states what the tool lists, but does not mention whether it is read-only, has side effects, or any other behavioral traits. This is a transparency gap for a model inspection tool.

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

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

The description is a single concise sentence with no redundant words, front-loading the key information about what the tool does.

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

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

The tool is simple, and an output schema exists, so return values need no explanation. However, the unexplained 'source' parameter and lack of usage context make the description incomplete for an agent to invoke it correctly.

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

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

The input schema has one parameter 'source' with a default but no description, and schema coverage is 0%. The tool description does not explain this parameter at all, leaving the agent unsure of its meaning or valid values.

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

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

The description clearly states the tool lists model hierarchies with their levels and columns, using the verb 'Lista' and the resource 'jerarquias del modelo'. This distinguishes it from sibling tools like pbi_list_relationships and pbi_list_tables.

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 usage is implied by the tool's name and description: use it when you need model hierarchies. However, there is no explicit guidance on when to choose this over other listing tools or any exclusions/prerequisites.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only listing operation and discloses the output fields, but it does not explicitly confirm non-destructive behavior, permission requirements, or any limitations (e.g., effect of the 'source' parameter).

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

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

The description is a single, well-structured Spanish sentence that starts with the verb and includes only essential information. It is concise and front-loaded with no redundant content.

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

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

The tool is simple with one optional parameter and an output schema, so return values are covered. However, the description omits usage differentiation from sibling tools and fails to define the 'source' parameter, making it only partially complete for an agent selecting and invoking the 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 schema has one parameter 'source' with 0% description coverage, and the description does not mention it at all. The default 'live' suggests possible sources, but no valid values, behavior, or meaning are explained, leaving the agent without necessary 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 uses the specific verb 'Lista' (lists) with the resource 'medidas' (measures) and enumerates the included attributes: table, DAX expression, format, description, and folder. This clearly identifies the tool's function and differentiates it from sibling tools like pbi_list_tables or pbi_get_object.

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

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

The description provides no guidance on when to use this tool versus alternatives such as pbi_model_summary, pbi_list_tables, or pbi_search_model. It only states what the tool does, with no context about prerequisites or exclusions.

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