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 clearly states that the tool executes the query and returns metrics and optionally the execution plan. However, it does not mention whether execution is read-only, whether it has side effects, or any cost/performance caveats beyond being an analysis 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 well-structured with a front-loaded purpose statement, a concise explanatory paragraph, and clearly formatted Args/Returns sections. Every line contributes useful information without unnecessary verbosity or duplication.

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

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

Given no output schema, the description appropriately explains the return value as a dictionary containing query results, execution metrics, and optionally the execution plan. It also covers all parameters and the tool's core behavior. It could be slightly stronger with explicit notes on prerequisites or error behavior, but it is largely complete for safe invocation.

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

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

Schema description coverage is 0%, but the description fully compensates by documenting every parameter: dax_query, workspace, model, and include_execution_plan. It adds useful semantics like 'Name or ID', optionality, and the default behavior of include_execution_plan. This goes well beyond the bare schema.

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

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

The first sentence states a specific verb and resource: 'Analyze a DAX query for performance insights and execution plan.' It clearly distinguishes this from sibling tools like dax_query or sql_query by emphasizing performance analysis and execution plan generation rather than general query execution.

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

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

The description clearly implies this tool is for performance analysis and execution plan inspection, which gives the agent a clear sense of when to use it. It does not explicitly name alternatives or exclusion conditions, but the context is strong enough for correct selection among DAX-related siblings.

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 carries the full burden. It discloses that the tool returns a string containing performance analysis and recommendations, which is useful. However, it does not state whether the analysis is read-only, whether it executes the notebook, or what permissions or context are required.

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

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

The description is short, front-loads the purpose in a single sentence, and organizes remaining details under Args and Returns. The mention of ctx, which is not an input-schema parameter, is a minor structural downside, but overall the description is efficient and scannable.

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

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

With no annotations and no output schema, the description should cover side effects and usage context more thoroughly. It explains the purpose and return value, but does not say when to use the tool, whether it mutates anything, or what conditions make it applicable. For a simple two-parameter analysis tool, this is partially adequate but leaves clear gaps.

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

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

The input schema has 0% description coverage, so the description must compensate. The Args section usefully clarifies that workspace and notebook_id accept names or IDs and that ctx contains client information. However, ctx is not present in the input schema, and no format, type, or validation details are given for the 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 opening sentence names a specific verb (Analyze), a specific resource (a notebook's code), and the goal (performance optimization opportunities in Fabric). It is clear about what the tool does, though it does not explicitly contrast with related siblings like validate_pyspark_code or analyze_dax_query.

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

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

The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no conditions under which it should or should not be called. The intended use is only implied by the name and first sentence.

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 identifies the action as canceling but does not disclose side effects, whether cancellation is reversible, idempotency, or what happens to the job after cancellation. For a mutating/destructive operation, this is a significant gap.

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

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

The description is a single front-loaded sentence with no wasted words. It is efficient, though its brevity contributes to the lack of behavioral and parameter guidance captured in other dimensions.

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 three optional but completely undocumented parameters and no annotations or output schema, the description is not complete enough for an agent to call the tool reliably. It does not explain how to identify the notebook job instance being canceled or what the expected result is.

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 provides no information about how job_id, notebook, or workspace should be used or whether they are alternative identifiers. An agent cannot determine which parameter or combination is needed to cancel a specific job.

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

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

The description states a specific verb ('Cancel') and resource ('running notebook job instance'), and the name clearly distinguishes it from siblings like run_notebook_job and get_run_status. It is immediately obvious what this tool does.

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

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

The word 'running' implies the tool should be used only for active notebook jobs, which provides some guidance. However, it does not explicitly say when to use this tool over alternatives like get_run_status, nor does it mention conditions like job completion or prerequisite identifiers.

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 behavioral burden. It discloses that the tool clears session context and returns a confirmation string, but it does not explain what 'session context' includes, whether the action is reversible, or whether it affects other sessions or persisted state.

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: one clear action statement plus a one-line return description. Every sentence earns its place, and the key 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?

For a zero-parameter tool, the description is mostly adequate and it does mention the return value. However, with no annotations and no output schema, it should more explicitly define what 'session context' means and what state is lost after clearing, otherwise an agent may over- or under-estimate the tool's scope.

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 coverage is 100%, so there is no parameter information missing. The baseline of 4 applies because the description cannot add parameter-level value beyond what the schema already makes clear.

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 ('Clear') and a clear resource ('current session context'), so an agent immediately knows what the tool does. It is also naturally distinguished from sibling tools like set_workspace or list_tables, none of which perform this action.

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

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

The description provides no guidance on when to use this tool vs alternatives, no prerequisites, and no note on consequences. The intended usage is only implied by the tool's name and one-line description.

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 behavioral disclosure burden. It only states that the tool retrieves information, implying read-only behavior, but gives no details about defaulting behavior, return payload, error cases, or whether state is read from the currently selected workspace.

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

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

The description is a single focused sentence with no redundancy or fluff. It could be considered under-specified, but as a standalone sentence it is clear 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 tool with no output schema, no annotations, and a workspace parameter that has no schema-level description, the single sentence leaves too much to inference: workspace selection semantics, return format, and relationship to set_workspace or compute 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 schema has 0% description coverage for the single workspace parameter, and the description does not add meaning beyond the parameter name. It fails to explain what accepted values look like, what null means, or how the workspace parameter relates to the active workspace context.

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

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

The description clearly identifies a read operation on a specific resource: Spark cluster information, scoped to a workspace. It is distinguishable from sibling list/set tools, though it does not specify exactly what cluster fields are returned or whether it targets the current compute context.

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

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

No guidance is given on when to call cluster_info instead of other compute-related siblings such as set_workspace, set_warehouse, or list_lakehouses. It also does not state whether the optional workspace parameter overrides the current context or when omission is appropriate.

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

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

With no annotations, the description carries the behavioral burden. It discloses that the tool returns a dictionary with ID and status, and that workspace falls back to context, but it does not discuss idempotency, overwrite behavior, permission requirements, or failure modes 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 well-structured with purpose, args, returns, and an example. The example is long but earns its place by clarifying the nested pipeline_definition format. No section feels redundant, though the 'Perfect for...' sentence is slightly promotional.

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 four-parameter tool with a complex nested object and no output schema, the description is largely complete: it explains all parameters, illustrates the nested structure, and states the return value. It could be improved by noting potential validation failures or how an existing pipeline name is handled.

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 fully compensates. Every parameter is explained, and the detailed pipeline_definition example with activities and dependsOn gives an agent a concrete template for constructing valid input.

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: 'Create a Data Pipeline in a Fabric workspace with custom activities and dependencies.' This clearly differentiates it from sibling tools like pipeline_run or get_pipeline_definition, and the medallion architecture mention adds a concrete use case.

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 context for use: 'Perfect for orchestrating medallion architecture workflows (Bronze → Silver → Gold).' It does not explicitly mention alternatives or exclusions, but the creation-focused wording and example make the intended usage unambiguous.

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

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

With no annotations, the description carries the full behavioral burden. It explicitly states a new notebook is created and that the return value is an ID or error message, which covers the immediate outcome. However, it does not explain what 'advanced templates' do, whether the operation is idempotent, or what permissions are required.

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 main purpose, followed by a structured Args/Returns block. The inclusion of 'ctx' as an argument not present in the schema adds mild noise, but overall the text is efficient.

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

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

For a create operation with no output schema and no annotations, the description covers the core parameters and return format. It is incomplete in that it does not explain how this tool relates to the generic create_notebook and create_pyspark_notebook siblings, nor the meaning of 'advanced templates'.

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 Args section compensates by explaining workspace as name or ID, notebook_name, and template_type with its allowed values. The mention of 'ctx' is confusing because it is not present in the input schema, but the other parameter meanings are genuinely clarified.

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

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

The description opens with a clear verb and resource: 'Create a new notebook optimized for Microsoft Fabric using advanced templates.' It states what the tool does but does not explicitly differentiate it from sibling tools like create_notebook or create_pyspark_notebook, so it misses the top score for sibling 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 provides no guidance on when to use this tool versus alternatives such as create_notebook or create_pyspark_notebook. It lists arguments and return behavior but no context, 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 of behavioral disclosure. It does state that the function returns a confirmation string or an error message, which is useful, but it does not disclose side effects, whether creation is idempotent, permission requirements, or behavior when the lakehouse name already exists.

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

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

The description is a compact docstring: one clear purpose sentence, a short parameter list, and a returns note. Every line contributes necessary information 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?

The tool is a creation operation with no annotations and no output schema, so the description should provide more operational context. It confirms the return type but omits folder_id semantics, prerequisites, error conditions, and what 'a string confirming' actually contains, leaving an agent under-equipped to handle edge cases.

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 name, workspace (as 'Name or ID'), and description, but it omits the folder_id parameter entirely and references a 'ctx' argument that is not present in the input schema. This mismatch and omission leave parameter understanding incomplete.

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 'Create a new lakehouse in a Fabric workspace,' which is a specific verb plus resource and clearly conveys the tool's primary action. It does not differentiate the tool from siblings like create_warehouse or set_lakehouse, but the resource 'lakehouse' makes the purpose unambiguous.

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

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

The description gives no guidance about when to choose this tool over alternatives, such as set_lakehouse for selecting a current lakehouse or create_warehouse for creating a different resource type. The optional workspace argument hints at context, but there is no explicit 'use this when' or 'instead of' 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?

There are no annotations, so the description carries the behavioral disclosure burden. It does state that this creates a measure and that the return value includes a success status and created details. However, it does not disclose behavior around duplicate measure names, persistence/commit semantics, or how optional workspace/model defaults are resolved from ctx.

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 one-line purpose followed by a structured Args list that maps directly to the 8 parameters, plus a Returns line. There is no fluff, and the examples for format_string earn their place because the schema provides no descriptions.

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, no output schema, and no schema descriptions, the description is substantially complete: it covers the operation, every parameter, and the return contract. Minor gaps remain around duplicate handling, error behavior, and a fuller explanation of how ctx supplies default workspace/model 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 input schema has 0% description coverage, but the description's Args section defines all 8 parameters with plain-language meaning, defaults, optionality, and format string examples. This fully compensates for the schema gap.

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

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

The description opens with a specific verb+resource: 'Create a new DAX measure in a semantic model.' The word 'new' clearly distinguishes this from update_measure and delete_measure, and the artifact type is specific enough to avoid confusion with other siblings.

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

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

The description gives clear context for when to use the tool: when a new DAX measure should be created. Sibling names like update_measure and delete_measure make the lifecycle role obvious, but the description does not explicitly direct agents away from those alternatives or mention prerequisites like an existing semantic model.

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 usefully reveals that omitting content creates a basic Hello Fabric notebook and that the return value is a string ID or error message. However, it does not disclose behavior on name collisions, permission requirements, or side effects beyond creation, which matters for a mutating 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 well structured with a one-line purpose, then compact Args and Returns sections. Every sentence adds value needed for invocation, and there is no filler. It is appropriately sized for a tool with three parameters.

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 creation tool, the description covers the required workspace parameter, optional defaults, and the return format. It is missing guidance on distinguishing this tool from notebook-creation siblings and on what the JSON content structure should look like, but an agent can still make a valid minimal call using only the required workspace 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?

Schema description coverage is 0%, so the description must compensate, and it does. It explains workspace as a name or ID, notebook_name as the name, content as JSON with a default fallback, and even documents ctx. This gives an agent enough meaning to invoke the tool correctly without relying on the bare property names.

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

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

The description states a clear verb and resource: 'Create a new notebook in a Fabric workspace.' It is unambiguous about the core action, and the mention of Fabric workspace provides useful scope. However, it does not differentiate from sibling tools like create_fabric_notebook or create_pyspark_notebook, leaving potential selection ambiguity.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The description does not mention that create_fabric_notebook or create_pyspark_notebook might be more appropriate for framework-specific notebooks, nor does it state any conditions that should route an agent to this tool. The optional content behavior is noted, but not framed as a usage decision.

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 explain behavior itself, and it does state that a notebook is created and that the return value is either a notebook ID or an error message. However, it does not disclose permission requirements, naming rules, overwrite/idempotency behavior, or what creating from a 'template' actually does to the notebook content.

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 main action, followed by a clearly structured Args/Returns section. The only real issue is the extraneous 'ctx' entry, which makes the structure slightly less reliable despite being concise.

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 basic call contract: what is created, the key parameters, and the return format. But with no annotations, no output schema, and zero parameter descriptions in the schema, it should also cover prerequisites, template behavior differences, and how to choose among the notebook-creation siblings; those gaps prevent it from being fully complete.

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

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

Schema description coverage is 0%, so the Args block adds genuinely useful meaning: it clarifies that workspace accepts a name or ID and lists the template_type options ('basic', 'etl', 'analytics', 'ml'). However, the description also lists 'ctx' as an argument even though it is not present in the input schema, which is confusing and could lead an agent to pass an invalid parameter; it also omits the default value of template_type.

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

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

The description uses a specific action ('Create') with a concrete resource ('new PySpark notebook from a template in a Fabric workspace'), so the core purpose is immediately clear. It does not explicitly distinguish this tool from the overlapping sibling tools create_notebook and create_fabric_notebook, which prevents a perfect 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 gives no guidance on when to use this tool versus create_notebook, create_fabric_notebook, or generate_pyspark_code. An agent cannot determine which sibling is the correct choice based on this description 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?

There are no annotations, so the description carries the full behavioral burden. It discloses the return value (confirmation or error string), which is helpful, but it does not mention side effects, idempotency, duplicate handling, permissions, or what happens when optional fields are omitted.

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 core purpose. The Args/Returns structure is scannable, though the Args list partially duplicates the schema and includes an extra 'ctx' entry.

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 create operation with no annotations and no output schema, the description should clarify more behavior. It fails to mention folder_id, does not explain the default workspace behavior when workspace is omitted, and introduces a 'ctx' argument not present in the schema. The return description is useful but not enough to make the tool fully self-contained.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning for name, workspace, and description by explaining their roles and optionality. However, it omits folder_id entirely and lists a 'ctx' parameter that does not appear in the input schema, creating potential confusion.

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

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

The description states a clear verb ('Create'), a specific resource ('a new warehouse'), and a context ('in a Fabric workspace'). It is immediately distinguishable from sibling tools like create_lakehouse and create_workspace because the resource is explicit.

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

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

No guidance is provided about when to use this tool versus alternatives, nor prerequisites such as setting a workspace first. The description only notes that workspace is optional, but does not explain the implications of omitting it or how this relates to sibling tools like set_workspace or create_lakehouse.

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 states the action (creation) and the return value ('A string confirming creation or an error message'), which provides baseline transparency. However, it does not disclose side effects, permission requirements, or behavior when a workspace with the same name already exists.

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

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

The description is tightly structured as a docstring with Args and Returns sections. Every sentence serves a purpose, and the core action is front-loaded.

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

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

For a simple create operation with four flat parameters and no output schema, the description covers purpose, parameters, and return type, leaving the agent with enough to invoke it. It falls short only on usage guidance and edge-case behavior, which are penalized in other dimensions.

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 explain parameters. It lists display_name, capacity_id, description, domain_id, and ctx with one-line meanings, adding value beyond the schema's bare property titles. The explanations are concise and adequate, though not deeply detailed.

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 'Create a new Fabric workspace', which is a specific verb+resource pairing. It clearly distinguishes this tool from siblings like create_warehouse and create_lakehouse without ambiguity.

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

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

No guidance is given on when to use this tool versus alternatives such as set_workspace or list_workspaces. The description does not mention preconditions, exclusions, or scenarios that favor 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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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 the deletion action and a vague return of success status and details; it does not mention that deletion is destructive/permanent, potential dependency impacts, permission requirements, or behavior when the measure does not exist.

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

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

The description is compact and front-loaded with the primary intent. The Args and Returns sections are organized and contain no fluff, making it easy to scan quickly.

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

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

For a destructive operation with no annotations and no output schema, this description is not complete enough. It omits irreversibility, side effects, error behavior, and the actual structure of the returned dictionary, leaving an agent without enough context to confidently 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?

The Args section adds meaning by describing measure_name as the measure to delete, and workspace/model as optional names or IDs, which is useful given 0% schema description coverage. However, the explanations are minimal, and 'ctx' is documented as an argument even though it is absent from the input schema, which could confuse an 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 opens with 'Delete a DAX measure from a semantic model', a specific verb and resource. This clearly differentiates it from sibling measure tools such as create_measure, update_measure, list_measures, and get_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?

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no warning about cases where deletion may be inappropriate. The description never addresses that measures might have dependencies or that other operations could be more suitable.

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

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

No annotations exist, so the description carries the full burden of behavioral disclosure. 'Delete' conveys destructiveness but does not state whether the operation is permanent, idempotent, or what happens to messages or aliases that reference the deleted alias.

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

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

The description is a single, front-loaded sentence with no fluff or repeated schema information. Every word contributes to the definition.

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

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

For a one-parameter deletion tool with no output schema, this is nearly sufficient, but without annotations it leaves important context unstated: permanence, error behavior for missing aliases, and relationship to saved/list alias tools.

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%, and the description does not explain the alias parameter beyond the tool's name and the word 'alias.' It does not specify the expected format (e.g., friendly name vs. ID) or how the alias is identified.

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

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

States a specific verb and resource: 'Delete a saved Teams channel alias.' The action (delete) and noun (saved Teams channel alias) clearly set it apart from sibling tools like save_teams_channel_alias and list_teams_channel_aliases.

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

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

The description gives no explicit when-to-use guidance or alternatives. An agent must infer that this is for removing an alias; there is no mention of prerequisite, relation to graph_teams_message_alias, or consequences of deleting an in-use alias.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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 behavioral burden. It discloses that the tool returns a string and mentions a ctx object, but it does not state whether the generated code is executed or only returned, whether the tool has side effects, or whether a lakehouse/workspace context must be set beforehand.

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 docstring is compact, uses clear Args/Returns structure, and front-loads the purpose. The phantom ctx parameter is a minor structural blemish, but overall the description is appropriately sized and scannable.

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

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

The description covers the basics: what the tool does, its arguments, and return value. However, it does not explain how the parameters interact with the chosen operation, which parameters are needed for which operation type, or why ctx appears in the description but not in the schema. With no output schema, these gaps 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 adds real value for operation by listing allowed values and clarifies target_table's role in write/merge operations. However, it documents a ctx parameter that is absent from the input schema, and lakehouse_name and table_name are only minimally 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 a specific verb ('Generate') and resource ('Fabric-specific PySpark code for lakehouse operations'), making the tool's core purpose immediately clear. The enumerated operation types (read_lakehouse, write_lakehouse, merge_delta, performance_monitor) further differentiate it from sibling tools like generate_pyspark_code.

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 operation values imply the intended use cases, but there is no explicit guidance on when to choose this tool over alternatives such as generate_pyspark_code or validate_fabric_code. No exclusions, prerequisites, or 'use this instead when...' statements are provided.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does disclose the return type as a string of code or an error message, which adds some transparency. However, it does not explicitly state that code is only generated and not executed, nor does it mention preconditions or side effects.

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

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

The description is well-structured with a front-loaded summary and clear Args/Returns sections. It is efficient overall, though the mention of the non-schema 'ctx' parameter adds minor noise.

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

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

The description is reasonably complete for a simple code-generation tool, but it lacks operation-specific parameter requirements, examples, and details about error conditions. Since there is no output schema, more detail about what the generated code looks like would improve 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?

The description adds useful meaning beyond the schema by listing operation enum values, table name formats, and comma-separated columns. However, it omits which parameters are required for each operation type, which is essential for correct invocation, and it mentions a 'ctx' parameter that is not present in the input schema.

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

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

The description states a specific verb and resource: 'Generate PySpark code' and lists five concrete operation types. This clearly distinguishes it from siblings like validate_pyspark_code and generate_fabric_code by technology and output.

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 validate_pyspark_code, create_pyspark_notebook, or generate_fabric_code. The operation list implies a use case, but no explicit conditions or exclusions are provided.

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

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

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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 disclosure. It states the return value ('measure definition including DAX expression') but does not mention read-only/side-effect behavior, errors, permissions, or behavior when workspace/model are omitted.

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 one-line summary is front-loaded and the Args/Returns structure is scannable with no filler. It is appropriately sized for a simple retrieval 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?

Adequate for a simple getter: it identifies the required parameter and the return content. It lacks details about relying on current context when workspace/model are omitted, error behavior, and the exact shape of the returned measure definition.

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 gives one-line meanings for measure_name, workspace, model, and a non-schema ctx argument. The descriptions are helpful but minimal, and the inclusion of ctx not in the input schema introduces 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?

States a precise action: retrieving a specific DAX measure definition by name. This clearly distinguishes it from list_measures, create_measure, update_measure, and delete_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 phrase 'specific ... by name' implies use when a single measure's definition is needed, but it never explicitly contrasts with list_measures or explains when not to use it. No prerequisites or context requirements 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 available, the description carries the behavioral disclosure burden, and it does convey that the tool retrieves the model definition in TMSL format, parses the structure, and returns a dictionary. However, it omits details about error behavior, permissions, and how omitted parameters are resolved in the current context, so the disclosure is only partial.

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 clear opening statement, a short implementation note, an Args section, and a Returns section. It is slightly redundant because the components 'tables, columns, measures, and relationships' appear in both the first sentence and the Returns line, but overall the text is focused and efficient.

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

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

For a read-only schema retrieval tool, the description adequately covers the main action, optional inputs, and the general shape of the return value. It is less complete because it gives no usage guidance, no error or failure behavior, and no explanation of how the optional workspace and model parameters resolve relative to the current 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 input schema has zero parameter descriptions, so the Args block is important and does add that workspace and model are optional 'Name or ID' values. It does not explain how the parameters interact with context or how the optionality is resolved, and it lists 'ctx' as an argument even though ctx is not present in the input 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 identifies the operation as retrieving the complete schema of a semantic model and enumerates the included components: tables, columns, measures, and relationships. However, it does not explicitly differentiate itself from the sibling tool 'get_semantic_model', leaving some ambiguity about which tool returns what.

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 when-to-use or when-not-to-use guidance, and no mention of alternatives such as 'get_semantic_model', 'list_semantic_models', or 'table_schema'. The description states what the tool does but gives no assistance in selecting it over the many related sibling tools.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It communicates a read operation via 'Get' and discloses the return format as 'a string containing the notebook content in JSON format or an error message.' It does not mention permissions, side effects beyond reading, or rate limits, but this is a simple read 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 compact docstring with an Args/Returns structure. Each line earns its place, and the key information is front-loaded in the first sentence. The only minor issue is including ctx, which is not part of the input schema.

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

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

For a simple 2-parameter read tool with no output schema, the description is largely complete: it explains what the tool returns (JSON string or error message) and clarifies that both parameters accept names or IDs. It would benefit from a note that this is a read-only operation, but the verb 'Get' conveys that reasonably.

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 only provides field names with no descriptions (0% coverage), so the description must compensate. It does: 'workspace: Name or ID of the workspace' and 'notebook_id: ID or name of the notebook' add meaningful detail about accepted value forms. The mention of ctx in Args is confusing because ctx is not in the input schema, but the actual callable params are well clarified.

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

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

The description states a specific verb and resource: 'Get the content of a specific notebook in a Fabric workspace.' It clearly distinguishes this from siblings like list_notebooks (listing only) and run_notebook_job (executing), even without saying so explicitly.

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

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

The description gives no guidance on when to use this tool versus alternatives such as list_notebooks, get_report, or run_notebook_job. There are no conditions, exclusions, or alternative tool names 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 provided, the description carries the full burden of behavioral disclosure, and it does disclose a key non-obvious trait: the API limitation means item-level permission requests are not honored. It does not go further to explain what happens with the required item_id parameter or any auth requirements, but the main behavioral surprise is addressed.

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 sentences and contains no filler. The primary purpose is stated first, and the important API limitation is provided as a brief, focused note.

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 central scope shift to workspace-level permissions, but it leaves a significant gap: the item_id parameter is required yet unexplained, and there is no output schema to clarify the return shape. An agent can invoke the tool, but may be confused about why item_id is necessary and what exactly the response will contain.

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 either parameter's meaning beyond implying 'workspace' is the target workspace. The required item_id parameter is especially problematic: the note says item-level permissions are unsupported, but the description never clarifies why item_id is required or how it is used.

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 ('Retrieve') and resource ('role assignments for a workspace'), so the tool's purpose is immediately obvious. The note about Fabric REST API not supporting item-level permissions distinguishes this from item-level permission operations and reinforces the workspace-level scope.

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

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

The description provides a clear usage context by explicitly stating that item-level permissions are not supported and that workspace-level role assignments are returned instead. It does not explicitly name alternative tools such as set_permissions, but the caveat effectively tells an agent what to expect and when this tool is appropriate.

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

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

With no annotations provided, the description carries the full burden. It conveys that this is a read-only 'Get' operation, that it returns a dictionary with decoded activities and dependencies, and that workspace falls back to context. It does not detail error behavior or permissions, but the non-mutating nature is reasonably clear.

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 well-organized into Args, Returns, and an Example. Every section adds useful information, and the example demonstrates realistic invocation. There is no filler or redundancy.

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

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

For a simple two-parameter getter, the description provides enough context: it explains the return value, the meaning of each parameter, and an example. Since there is no output schema, the Returns section is valuable. The main gaps are lack of explicit error/not-found behavior and any mention of permissions, but these are not critical for this tool.

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

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

Schema description coverage is 0%, so the description must compensate. It does so by explaining that pipeline accepts a name or ID and that workspace is an optional name or ID that uses context when omitted. However, it also lists 'ctx' as an argument even though it is absent from the input schema, which could cause confusion.

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

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

The description states a specific verb and resource: 'Get the definition of an existing Data Pipeline including activities and dependencies.' This clearly distinguishes it from sibling tools like create_data_pipeline, pipeline_run, and pipeline_status.

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

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

The description makes the purpose clear and notes that workspace is optional, but it does not explicitly state when to use this tool versus alternatives such as create_data_pipeline or pipeline_logs. The word 'existing' implies it is for reading, not creating, but no explicit exclusions or alternative routing are provided.

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

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 only says the tool returns a report string or an error message, but does not disclose side effects, authorization needs, behavior when both parameters are omitted, or how workspace context affects the lookup. This is minimal transparency for a tool that accesses report data.

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 core purpose, followed by an Args section and Returns line. The formatting is scannable and the length is appropriate for a simple retrieval tool. Minor redundancy exists because the schema already marks both parameters as optional, but the overall structure is clean.

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

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

For a tool with two optional parameters, no required fields, no annotations, and no output schema, the description is incomplete. It does not specify whether report_id is effectively required for a meaningful call, what the returned string contains beyond 'report details', or how errors are surfaced. An agent would need to guess at the correct invocation pattern.

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

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

Schema description coverage is 0%, so the description must compensate for the bare input schema. It adds useful semantics by stating workspace is a 'Name or ID' and that both parameters are optional, and it mentions a ctx argument, though ctx is not present in the schema. However, it does not explain the relationship between workspace and report_id or what happens if neither is provided, leaving important 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 a specific action and resource: 'Get a specific report by ID.' It is unambiguous about what the tool does and, by mentioning ID-based retrieval, it is implicitly distinct from list_reports. However, it does not explicitly name sibling tools or contrast them, so it stops short of a perfect 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 provides no guidance on when to use this tool versus alternatives like list_reports or report_export. It does not state prerequisites, whether a report_id is required, or when the workspace parameter should be supplied. This leaves the agent to infer usage from the tool name and one-line summary.

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 must disclose behavioral traits itself. It does reveal that the tool polls until completion, implying a blocking/waiting behavior, but it does not explain whether it returns a final status, how it handles failed runs, whether it can time out, or what side effects (if any) it has. The absence of any read-only or destructive hints leaves the safety profile 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 efficient sentence that front-loads the verb and object without filler. It is concise, but it is also somewhat undersized for the amount of context the tool needs; slightly more structure or detail would make it more useful without sacrificing readability.

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?

There is no output schema and no annotations, so the description is the only source of behavioral and semantic context. It does not explain what the tool returns, how to identify the job run to poll, or what 'until completion' means in terms of blocking, polling interval, or timeout. The definition is too thin for an agent to invoke the tool with confidence in a non-trivial workflow.

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

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

Schema description coverage is 0%, and the description provides no information about job_id, notebook, or workspace. The parameter names are only weakly self-descriptive, and the relationship between them, their formats, and their optionality are entirely unexplained. For a tool with three nullable parameters and no required fields, this is a critical 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 identifies a specific verb ('poll') and resource ('notebook job run') and states the intended terminal condition ('until completion'). This makes the basic purpose understandable and distinguishes it from run/cancel operations, though it does not explicitly differentiate it from sibling status tools like pipeline_status or clarify what the returned status looks like.

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 'poll a notebook job run' implies that this tool should be used after starting a notebook job and when the caller wants to wait for that job to finish. However, there is no explicit guidance about when to use this tool versus run_notebook_job, cancel_notebook_job, or pipeline_status, and no mention of 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 behavioral burden. It discloses the return shape ('A string containing the details of the semantic model or an error message'), which is genuinely useful. However, it does not explain failure modes beyond a generic 'error message', what 'details' includes, whether the optional workspace falls back to the current context, or the behavior when both optional parameters are omitted. Non-zero disclosure, but several behaviors remain opaque.

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 structure is clean and front-loaded: a one-line summary followed by a compact Args block and a Returns block. Every line earns its place given the 0% schema coverage. The only blemish is the 'ctx: Context object containing client information' line, which describes a parameter not present in the input schema and could mislead an agent into trying to pass it.

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 — a get-by-ID read with no output schema and no annotations — the description covers the essentials: purpose, both parameters, and return format. But material gaps remain: it never clarifies what occurs when both optional parameters are unused, and it offers no pointer to list_semantic_models for discovering valid model IDs before calling this tool. Adequate for a simple tool, but not thorough.

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% — the schema offers only bare titles ('Model Id', 'Workspace') with no descriptions. The description compensates by defining workspace as 'Name or ID of the workspace' and model_id as 'ID of the semantic model', adding real semantic meaning the schema lacks. It does not go as far as explaining the relationship between the two options (e.g., whether workspace is needed to disambiguate a model_id), but the compensation is solid.

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

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

The description opens with a clear verb+resource statement: 'Get a specific semantic model by ID.' The 'by ID' qualifier meaningfully distinguishes this from the sibling list_semantic_models tool, which enumerates models rather than fetching one. It stops short of a 5 because it does not explicitly name the sibling alternatives it is not, leaving the agent to infer the 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?

Usage context is only implied through the 'by ID' phrasing — an agent can infer this is for retrieving a single known model, while list_semantic_models would be for discovery and get_model_schema for schema details. There is no explicit when-to-use/when-not-to-use statement, no mention of prerequisites (e.g., needing a valid workspace context), and no routing to sibling tools, so the guidance is adequate but entirely implicit.

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

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

With no annotations, the description must carry the burden of behavioral disclosure. It does state the return format and mentions that type inference occurs, which is useful. However, it does not disclose side effects, error behavior, authentication needs, or how conflicting arguments like both lakehouse and warehouse being provided are handled.

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

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

The description is front-loaded with a clear one-sentence summary followed by structured Args and Returns sections. It is concise overall, though documenting a 'ctx' parameter that is absent from the input schema adds minor confusion and could mislead callers.

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 parameters and return value, which is helpful given there is no output schema. However, it omits important calling constraints: whether lakehouse and warehouse are mutually exclusive, what happens if neither is provided, and what errors may occur. This leaves the tool minimally viable but with clear gaps.

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

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

Schema description coverage is 0%, so the description's parameter list adds essential meaning. It explains workspace, lakehouse, and warehouse as names or IDs, and type as 'lakehouse' or 'warehouse' with inference when omitted. It does not define constraints such as mutual exclusivity or the minimum set of required arguments, but it compensates for the empty 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 opening sentence names a concrete action ('Retrieve') and a specific resource ('SQL endpoint for a specified lakehouse or warehouse'). This clearly communicates what the tool does and is distinguishable from generic list or schema tools, though it does not explicitly contrast it with any sibling tool.

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

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

There is no guidance about when to use this tool versus alternatives such as set_lakehouse, list_warehouses, or sql_query. No prerequisites, exclusions, or decision rules are provided; the only usage signal is implied by the purpose statement.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'List files' clearly indicates a read-only operation, which is helpful. However, it does not say whether folders are included, whether traversal is recursive, whether results are paginated, or what metadata is returned.

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

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

The description is a single, focused sentence that front-loads the verb and resource. There is no filler, repetition, or tangential information, making it highly efficient for an agent to parse.

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

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

Given that there is no output schema and no annotations, the description is too sparse to be fully actionable. It omits path semantics, return value shape, pagination behavior, and the difference between OneDrive and SharePoint drive handling, leaving important gaps for an agent trying to invoke the tool correctly.

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

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

Schema description coverage is 0%, and the description adds almost no parameter-level meaning. 'Drive Id' is understandable from its name, but the optional 'path' parameter is not explained at all - the agent is left guessing whether it is a folder path, file path, or Graph item path. The description merely repeats 'drive' rather than clarifying inputs.

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

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

The description uses a specific verb and resource: 'List files in a OneDrive or SharePoint drive via Microsoft Graph.' This immediately makes the tool's purpose clear. It also distinguishes the tool from sibling Graph-based tools like graph_mail and graph_user, and from listing tools like onelake_ls, by scoping to OneDrive/SharePoint drives.

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 this tool is for listing files in OneDrive or SharePoint drives, giving the agent a sense of when it should be selected. However, it does not explicitly name alternatives or state when not to use the tool, leaving the usage boundary to be inferred from the sibling tool 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'on behalf of the current identity,' which hints at auth context, but it does not disclose side effects, permissions needed, whether sending is irreversible, or what happens on failure. For a side-effecting email-sending action, this is a significant gap.

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

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

A single sentence that front-loads the verb and entity, includes a useful identity qualifier, and contains no filler. It earns every word.

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 three-string-parameter tool with no output schema, the description is minimally viable: it tells the agent what action to take and under whose identity. However, with no annotations and no return-value information, it leaves behavioral and edge-case details unspecified.

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

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

Schema description coverage is 0%, so the description must compensate, but it adds no parameter-level detail. The parameter names 'to', 'subject', and 'body' are self-evident in an email context, but the description does not clarify formats, recipient syntax, or body type.

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

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

The description states a specific action ('Send mail') and resource ('via Microsoft Graph'), and clarifies the acting identity ('current identity'). This clearly distinguishes it from sibling graph_teams_message, which sends Teams messages instead of email.

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

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

The description gives clear context: use this tool to send email as the current user via Microsoft Graph. It does not explicitly name alternatives or say when not to use it, but the 'mail' vs. 'teams_message' distinction is apparent enough that an agent can select appropriately.

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 says 'Post a message' and describes parameters; it does not mention permissions required, side effects, send semantics, rate limits, or what happens on failure. This is a meaningful gap for a mutation-style 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 compact and well-structured: one clear purpose sentence followed by a concise Args block. Every line adds useful information, 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?

The parameter semantics are fully specified, which is enough for basic invocation. However, with no output schema and no annotations, the description still omits return behavior, confirmation, and any guidance on when to select this tool over similar siblings, so it is 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 provides only types and a default, with 0% description coverage, so the description fully compensates. It explains team_id, channel_id, text, and content_type, enumerates the valid content_type values, and states the default explicitly.

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

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

The description clearly states the action and resource: 'Post a message to a Teams channel via Microsoft Graph.' The Args block further specifies the target team and channel. However, it does not explicitly distinguish this from the similar sibling tool graph_teams_message_alias, so sibling differentiation is weaker than ideal.

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

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

There is no guidance on when to use this tool versus alternatives. The description lists arguments but never states when a direct team/channel message is appropriate or when the alias-based sibling should be used instead.

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 explains the alias resolution and forwarding behavior, but it does not mention what happens for invalid aliases, whether permissions are needed, or any side effects beyond posting the message. This is adequate for a simple wrapper but not richly 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 two concise sentences with no filler. The primary action is front-loaded, and the follow-up sentence provides useful implementation detail about alias resolution and forwarding. Every sentence earns its place.

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

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

For a simple wrapper tool, the description provides a reasonable baseline: it states what it does and where it forwards. However, there is no output schema or annotations, and the description does not cover error behavior, response format, or content_type semantics, leaving some context missing for an agent.

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

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

The schema has 0% description coverage, so the description must compensate. It adds meaningful semantics for alias by explaining that it is a saved alias resolved into team_id and channel_id. Text is reasonably implied by 'post a message', but content_type is left completely unexplained, including its default 'html' and allowed 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 states a specific action and resource: posting a message to a Teams channel via a saved alias. It also clarifies the internal behavior by explaining that the alias resolves to team_id and channel_id and is forwarded to graph_teams_message, 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 that this tool should be used when a saved alias is available, since it resolves the alias and forwards to graph_teams_message. However, it does not explicitly contrast this with graph_teams_message or state when an agent should choose one over the other; the usage guidance is left to inference.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. The verb 'Query' implies a read-only operation, which is useful, but the description does not mention required permissions, response format, or any limitations such as pagination or field availability.

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

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

The description is a single, front-loaded sentence with no filler. It conveys the essential purpose in as few words as possible.

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

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

For a simple single-parameter read tool, the description is adequate but minimal. It lacks explicit mention of the input parameter in prose and does not describe what the returned profile details contain, which matters because there is no output schema to fill that gap.

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

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

The schema has one required parameter, 'email', with no description, and the tool description provides zero parameter guidance. The parameter name is self-explanatory enough to guess, but the description does not compensate for the 0% schema description coverage by explaining how the email is used or formatted.

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 ('Query'), a specific resource ('Azure AD user profile details'), and the access mechanism ('Microsoft Graph'). This distinguishes it from sibling Graph tools like graph_mail, graph_drive, and graph_teams_message, which target different resources.

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

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

The description provides clear context that this tool is for retrieving Azure AD user profile data, which makes the appropriate usage scenario reasonably inferable. However, it does not explicitly mention when not to use it or name alternatives, so it stops short of full 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 full responsibility for behavioral disclosure. It only says 'Install', which signals a mutation, but does not state whether packages are overwritten, whether permissions are required, whether the install is persistent within the Spark session, or what side effects or outputs to expect.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately concise for its simple purpose, though it omits parameter and usage details that would make it more useful.

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

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

For a tool with two undocumented optional parameters, no annotations, no output schema, and a closely related sibling (install_wheel), the description is too thin. It gives no guidance on required inputs, preconditions, or expected behavior after invocation, so an agent would struggle to call it correctly in a real scenario.

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 either parameter. An agent cannot infer that 'requirements_txt' likely holds the contents of a requirements.txt file or that 'workspace' selects the target environment. This is a significant gap since no structured descriptions exist to compensate.

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

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

The description states a clear verb ('Install') and resource ('Python requirements') with a target environment ('workspace Spark environment'). It is distinct enough from the sibling install_wheel by implying requirements.txt rather than .whl files, though it does not explicitly name that 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?

No guidance is given on when to use this tool versus install_wheel, nor are prerequisites such as needing a configured workspace mentioned. The wording implies a workspace context but stops short of instructing the agent to set one first or explaining how install_requirements differs from other package installation 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 provided, the description carries the full burden of behavioral disclosure, but it only says 'install' with no details about side effects, persistence, dependency handling, permissions, or failure modes. The mutating nature of the operation is implied but not elaborated.

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

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

The description is a single, well-structured sentence that front-loads the action, resource, and destination with no filler or repetition. It is concise without sacrificing the core purpose.

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

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

For a tool with two parameters, no annotations, and no output schema, the description is too sparse to fully guide an agent. Missing details include how to form the wheel URL, what the workspace parameter means, whether installation is session-scoped or persistent, and what success or failure looks like.

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 adds no meaning for 'wheel_url' or 'workspace' beyond their names and defaults. 'wheel_url' is somewhat self-explanatory from its title, but 'workspace' remains ambiguous—whether it selects the target environment or requires a prior set_workspace call is not clarified.

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 ('Install'), a concrete resource ('a wheel package'), and a target environment ('workspace Spark environment'), making the tool's purpose clear. It is implicitly distinct from the sibling install_requirements because it specifically targets wheel packages, though it does not explicitly name that alternative.

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 like install_requirements, nor any mention of prerequisites, expected wheel URL formats, or whether a workspace must be set first. The usage context is only implied by the description and parameter names.

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

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

With no annotations, the description carries the full burden and does state the core read-only behavior and optional filters. However, it does not disclose pagination semantics, default result sizes, return shape, or how the workspace parameter affects results, leaving the agent with only minimal 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 a single, front-loaded sentence with no filler or unnecessary wording. It is appropriately concise, though it sacrifices some useful context that would be needed for a higher completeness score.

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, no output schema, five parameters, and many list_* siblings, the description is too thin for reliable selection and invocation. It does not explain what 'items' includes, how list_items relates to the specialized list tools, or how workspace selection works.

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 only clarifies 'type' and 'search term,' leaving 'top,' 'skip,' and 'workspace' unexplained; it also does not specify valid values for 'type.' This is only partial coverage of the five 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 verb 'List' and the resource 'workspace items,' and it mentions optional filtering by type or search term. However, it does not explicitly distinguish this generic tool from the many sibling list_* tools like list_reports or list_tables, so it stops short of full clarity.

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

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

The description gives no guidance on when to use list_items versus the numerous specific list_* sibling tools. There are no exclusions, prerequisites, or hints about which scenarios call for the generic tool instead of a specialized one.

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 behavioral disclosure burden. It states the return shape ('a string containing the list of lakehouses or an error message') and the read-only nature is implied by 'List.' It does not clarify behavior when workspace is null, or whether it uses the currently selected workspace, which leaves some ambiguity.

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

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

The description is concise and front-loaded with the primary purpose. The Args/Returns structure is easy to scan, though the ctx line adds little value for the agent since ctx is not a schema parameter.

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 listing tool with one optional parameter and no output schema, the description covers the core operation and return type. It is incomplete on behavior when workspace is omitted and on how the result relates to the current context, but it is adequate for a low-complexity tool.

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

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

The input schema only defines workspace as a nullable string with a default of null. The description adds meaningful semantics by stating workspace can be a 'Name or ID' and is optional. This compensates well for the 0% schema description coverage, though the mention of ctx is not reflected in the schema.

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

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

The description uses a clear, specific verb and resource: 'List all lakehouses in a Fabric workspace.' This unambiguously identifies the operation and scope. It does not explicitly contrast it with sibling tools like list_warehouses or list_tables, so it stops short of a 5.

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

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

The intended use is implied: call this tool when you need to enumerate lakehouses in a workspace. However, it does not state when to prefer this over related tools or what happens when workspace is omitted. There is no exclusions or alternative guidance.

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

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

With no annotations, the description must carry the behavioral burden. It does state that this is a listing operation and that the return value is a list of measures with definitions, which implies a read-only, non-destructive call. However, it does not discuss authentication, side effects, or behavior when no workspace/model is supplied.

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

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

The description is short and front-loaded with the main purpose, followed by a clear Args/Returns structure. The 'ctx' line is arguably unnecessary noise since it is not an input schema parameter, but it does not meaningfully hurt readability.

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 list operation, the description covers the essential behavior and return value. The lack of an output schema and annotations raises the burden, and the description does not clarify how optional workspace/model relate to the current context or how this tool fits with measurement-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 add parameter meaning. It does add 'Name or ID' and 'optional' for workspace and model, which goes beyond the schema's bare property names and null defaults. It stops short of explaining how the optional parameters interact with a default/current context, so it is adequate but not complete.

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

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

The description clearly states the action ('List') and the resource ('all DAX measures in a semantic model'), so an agent knows exactly what the tool does. It does not explicitly differentiate itself from siblings like get_measure or list_semantic_models, which keeps it at 4 rather than 5.

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

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

No guidance is given for when to use this tool instead of get_measure, list_semantic_models, or get_model_schema. The optional workspace/model arguments are described, but there is no explanation of when they are needed or what happens if they are omitted.

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 behavioral disclosure burden. It does state the return type ('a string containing the list of notebooks or an error message'), implying a read-only operation. However, it does not describe default workspace behavior, pagination, output format, or potential failure modes beyond a generic error message.

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 with the core purpose, followed by a compact Args/Returns breakdown. It avoids fluff, though including ctx in Args when it is not part of the exposed schema adds a small amount of unnecessary noise.

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

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

For a simple list tool with one optional parameter and no output schema, the description covers the main purpose and return behavior. The main gap is that it does not explain the semantics of omitting the workspace argument—whether it falls back to the current context or scans all workspaces—which is important for an agent to invoke the tool predictably.

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

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

Schema coverage is 0%, so the description must compensate. It does so by explaining that workspace is a 'Name or ID' and optional, which adds meaning beyond the raw schema's string/null type and default. The mention of ctx is slightly odd since it is not in the input schema, but it is a minor issue.

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

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

The description opens with a specific verb and resource: 'List all notebooks in a Fabric workspace.' This clearly identifies the tool's function and distinguishes it from sibling tools like list_reports, list_lakehouses, and list_workspaces.

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 scoping the action to a Fabric workspace and marking the workspace argument as optional. However, it does not explicitly state when to prefer this tool over alternatives such as list_items or other list_* siblings, nor does it explain what happens when workspace is omitted.

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 states it returns a list string or error, but it doesn't disclose whether it uses the current workspace context, how it behaves with no workspace, whether it requires permissions, or what the string format is. For a list tool, this is minimal.

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 structured with Args/Returns sections. It front-loads the main purpose in the first sentence. The docstring format is conventional. It earns a 4 because it is brief and clear, though it repeats parameter names from the schema.

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

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

Given no annotations, no output schema, and only one optional parameter, the description is under-specified. It doesn't explain the relationship to the workspace context, how errors are returned, or whether the list is filtered. Also, sibling tools like set_workspace suggest context matters, but the description doesn't clarify this.

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 says workspace is 'Name or ID of the workspace (optional)'. It doesn't add details about how workspace is resolved (e.g., if omitted, does it use the current context set by set_workspace?). This is a notable gap because the context object and optional workspace semantics are ambiguous.

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: 'List all reports in a Fabric workspace.' It distinguishes the tool as a listing operation for reports. However, it doesn't explicitly differentiate from sibling tools like list_workspaces or list_lakehouses, though the resource is specific enough.

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: call this to list reports in a workspace. It mentions the workspace parameter as optional, but it doesn't explain when to use this versus alternatives like get_report or report_export. No explicit exclusions or alternative routing are provided.

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

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

There are no annotations, so the description carries the behavioral burden. It discloses that the return value is a string and that errors are returned as messages, and 'List' implies a read-only operation. However, it does not mention pagination, limits, side effects, or how the optional workspace is resolved.

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 main purpose is front-loaded in a single clear sentence, followed by a compact Args/Returns block. Every line earns its place and there is no filler or redundancy.

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

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

For a simple one-parameter listing tool, the description provides adequate purpose, arguments, and return behavior. However, it does not explain what happens when workspace is omitted, especially given sibling tools like set_workspace and clear_context that imply a current-workspace concept. This ambiguity is a clear gap.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful semantics by stating that workspace accepts a name or ID and is optional, and it documents ctx as a context object. This goes well beyond the schema's bare nullable string property.

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

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

The description states a specific verb ('List'), a specific resource ('all semantic models'), and a scope ('in a Fabric workspace'). The 'all' qualifier also differentiates it from singular retrieval siblings like get_semantic_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 usage is implied by the imperative 'List all semantic models' — use it when you need an inventory of semantic models. However, it does not explicitly say when to prefer this over alternatives like get_semantic_model or get_model_schema, nor does it clarify behavior when workspace is omitted.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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. 'List all saved' makes the read-only, no-filter scope reasonably clear. It does not detail output format or edge cases, but the tool is simple enough that this is a minor gap.

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

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

The description is one short sentence with no filler. It states the key facts immediately: the operation is 'List' and the target is 'all saved Teams channel aliases.'

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, side-effect-free listing tool, the description is largely complete for selection and invocation. The only missing element is an explicit description of the return shape, but that is not critical for a simple list operation.

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

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

The tool has zero parameters, so the baseline is 4. The description reinforces that no filtering is possible by saying 'all saved,' which is sufficient since there is nothing else to document.

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

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

The description uses a specific verb and resource: 'List all saved Teams channel aliases.' This clearly communicates the action and the object being operated on. It does not explicitly contrast with sibling tools, but the list/save/delete sibling names make the distinction easy.

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

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

Usage context is implied but not explicit: an agent can infer this tool is for retrieving previously saved Teams channel aliases, but there is no guidance on when to prefer it over graph_teams_message_alias or how it relates to save/delete aliases.

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 discloses that the call returns a string containing the list or an error message, and that workspace is optional, but it does not explicitly confirm the operation is read-only or describe what happens when workspace is null.

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

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

The description is short, front-loaded, and follows a clean Args/Returns structure. The first sentence states the core purpose immediately, and there is little wasted text, though the ctx line adds minimal agent-facing value.

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

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

For a simple optional-parameter list operation, the return type is disclosed and there is no output schema to rely on. The main gap is the meaning of omitting workspace, which is relevant for a correct first invocation given the set_workspace sibling 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 no parameter descriptions (0% coverage), so the Args section is the only semantic source for parameters. It adds that workspace accepts a name or ID and is optional, and it mentions ctx; this is sufficient to construct a basic call, though the null-workspace behavior remains implicit.

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

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

The description opens with a specific verb-resource pair, "List all warehouses," and scopes it to "a Fabric workspace," which clearly distinguishes it from sibling tools like list_lakehouses, list_tables, create_warehouse, and set_warehouse. The purpose is unambiguous.

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

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

The description gives no explicit guidance on when to use this tool versus sibling list tools, nor does it explain when to provide or omit the optional workspace parameter. It also does not state whether omitting workspace falls back to the active context, so the agent must infer the intended invocation pattern.

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 behavioral burden. It implies read-only behavior through 'List' and discloses that it returns a string or an error message. However, it does not clarify the scope of 'available' workspaces, required permissions, or output formatting, leaving meaningful 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 compact and front-loaded with the core purpose, and the Returns line adds useful information. The 'ctx' line contributes little value for an MCP caller and feels somewhat unnecessary, but the overall structure is clean and readable.

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 listing tool, the description provides the basic purpose and return behavior, which is close to sufficient. However, absent annotations and an output schema, it could better explain what 'available' means and how this tool fits with workspace-related siblings like set_workspace.

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 is empty, so the 0-parameter baseline applies. The description mentions a 'ctx' argument, but it is not reflected in the schema and is described only generically as a context object. Since there are no actual agent-supplied parameters, the baseline of 4 is appropriate.

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

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

The description states 'List all available Fabric workspaces,' giving a specific verb and resource. This clearly distinguishes it from sibling tools like create_workspace and set_workspace. There is no ambiguity about what operation the tool performs.

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 set_workspace, create_workspace, or list_warehouses. Usage context must be inferred entirely from the tool name and sibling list, which is insufficient for an agent.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses the return shape ('a string confirming the data load or an error message') and supported formats, but omits the critical write semantics: whether destination_table is appended to, replaced, or required to not exist. It also does not state preconditions such as an established workspace/lakehouse context, auth requirements, or behavior on format mismatch.

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, well-structured docstring: a one-line summary front-loads the action, followed by a scannable Args list and a Returns line. Every line earns its place, though the ctx entry is arguably noise for user guidance since it is not part of the input schema.

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

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

For a tool with no annotations and no output schema, the description provides the essentials: purpose, every parameter, return value, and source format support. However, it omits behavior an agent needs to call it safely and correctly: what happens to existing data in destination_table (append vs. overwrite vs. error), whether the tool creates tables, and whether a prior set_workspace/set_lakehouse/set_warehouse context is required given those sibling tools exist.

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 largely compensates: all 5 schema parameters are documented with meaning beyond their types. The url entry adds format constraints ('CSV or Parquet supported'), destination_table describes its role, and warehouse adds a notable nuance ('uses SQL for warehouses'). Minor deduction: the docstring also lists ctx, which is not an invokable schema parameter, and the entries are terse with no examples or constraints.

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

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

The opening line states a specific verb and resource: 'Load data from a URL into a delta table in a lakehouse via OneLake.' It names the source (URL), the destination (delta table), the mechanism (OneLake), and the supported formats (CSV or Parquet). This clearly distinguishes it from siblings like onelake_write, sql_query, or vacuum_delta.

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 or when-not-to-use guidance is given, and no alternative sibling is named. The only contextual hint is the warehouse arg note ('uses SQL for warehouses'), which implies a warehouse-targeting mode but never states a condition that should route an agent to a different tool. The agent must infer appropriateness from the 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?

With no annotations provided, the description carries the burden of explaining side effects. It states that the shortcut references data without duplicating it, names the source and target locations, and documents conflict_policy behavior when a shortcut already exists. It does not discuss permissions or failure modes, but the core mutation behavior is 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 clear first sentence, a purpose statement, a compact args list, return description, and a concrete example. Every section adds useful information and there is no filler or 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?

For a tool with 8 parameters, no annotations, and no output schema, the description covers purpose, usage scenarios, parameter semantics, return value, and a complete invocation example. An agent has enough information to select and call the tool correctly.

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

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

Schema description coverage is 0%, but the description compensates fully by explaining every parameter with plain-language meaning. It clarifies source vs. target semantics, provides path format examples, explains the optional workspace behavior, and enumerates conflict_policy values. This is far beyond the bare schema property names.

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

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

The description states a specific action: creating a OneLake shortcut from one lakehouse to another. It clearly distinguishes this from sibling tools like onelake_list_shortcuts and onelake_delete_shortcut by naming the exact resource and relationship being created.

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

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

The description gives concrete usage context, such as avoiding data duplication and supporting medallion architectures where Dev/Test/Prod read from a central Bronze layer. It does not explicitly contrast with alternatives like onelake_write, but the intended scenario is clear enough for an agent to decide when 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 behavioral burden. It does disclose the return shape ('Dictionary with success status') and the workspace fallback ('uses context if not provided'), but it does not cover side effects such as irreversibility, whether the underlying data remains untouched, or failure behavior when the shortcut does not exist.

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

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

The purpose is front-loaded, followed by a compact Args list and a single example. Each line earns its place, with no filler or unnecessary repetition.

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

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

For a simple four-parameter delete operation, the description provides enough to invoke the tool correctly: all parameter meanings, optional workspace fallback, return value, and an example. It stops short of warning about side effects and edge cases, but the core calling context is complete.

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

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

Schema description coverage is 0%, and the description fully compensates by explaining every relevant parameter: lakehouse name/ID, shortcut_path with examples, shortcut name, and optional workspace behavior. The example further clarifies how the parameters are used together.

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

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

The opening sentence uses a specific verb and resource: 'Delete a OneLake shortcut from a lakehouse.' This clearly identifies the operation and distinguishes it from sibling tools like onelake_create_shortcut and onelake_list_shortcuts.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention exclusions or compare with onelake_rm, onelake_create_shortcut, or onelake_list_shortcuts. The only usage context is the one-line purpose and an example.

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 does communicate that this is a listing operation and returns a dictionary, which implies a read-only behavior. It does not mention permissions, error cases, or how shortcuts are represented in the returned dictionary.

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-organized into a summary, args, returns, and example, with no unnecessary prose. It is compact and front-loaded. The 'ctx' line adds minor noise but does not significantly hurt 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, and the description covers the main input parameters, the output type, and an example. However, with no output schema, 'Dictionary with list of shortcuts' is vague and does not explain the structure of the result, empty-result behavior, or possible errors. Given the absence of annotations, these are meaningful gaps.

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

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

Schema coverage is 0%, so the description must compensate, and it does: it explains that lakehouse is a name or ID and that workspace is optional with context fallback. The example further clarifies real usage. The mention of 'ctx' is a slight inconsistency since ctx is not in the input schema, but the example omits it, reducing confusion.

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

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

The description states a specific verb and resource: 'List all OneLake shortcuts in a lakehouse.' This is clear and unambiguous. It does not explicitly contrast with sibling tools like onelake_ls, but the 'shortcuts' entity makes the purpose understandable.

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 primary use case is implied by the verb 'List' and the example invocation. It also usefully notes that workspace is optional and uses context when not provided, which helps an agent decide whether to pass it. However, it gives no explicit guidance about alternatives 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 must carry the full behavioral disclosure burden, but it only states the listing action. It does not mention recursion behavior, path defaulting, workspace or lakehouse requirements, permissions, or return format, leaving the agent to guess.

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

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

The description is a single, front-loaded sentence with no filler or repetition. It is appropriately concise for a straightforward list operation, even though other dimensions penalize the lack of supporting detail.

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

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

For a tool with no annotations, no output schema, and three undocumented parameters, this description is not sufficient. An agent knows the tool lists files and folders but cannot reliably determine how to supply workspace/lakehouse/path or what the result structure looks like, especially given the large sibling toolset.

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

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

Schema description coverage is 0%, so the description must compensate, but it only clarifies that 'path' refers to a OneLake lakehouse path. It gives no meaning for the 'lakehouse' or 'workspace' parameters and no detail about default values or how the path is resolved.

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 'List' and resource 'files and folders within a OneLake lakehouse path,' which makes the core operation clear. It does not explicitly differentiate from sibling tools like onelake_list_shortcuts or list_lakehouses, so it stops short of full sibling differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives such as onelake_read, onelake_list_shortcuts, or list_lakehouses. The description only states the action and gives no contextual triggers, exclusions, or preferred usage patterns.

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?

There are no annotations, so the description must disclose behavior itself. 'Read file contents' conveys that this is a non-mutating operation, but it does not state return format, file type handling, size limits, or error behavior.

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

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

The single sentence is concise and front-loaded, containing no fluff. It is appropriately short for a simple read operation, though it sacrifices informative content for brevity.

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

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

With no annotations, no output schema, and three parameters, an agent is left without information about what the read returns, how the workspace parameter affects behavior, or how failures are surfaced. The description is too thin to be fully self-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?

Schema description coverage is 0% and the description does not explain the path, lakehouse, or workspace parameters. The parameter names are somewhat self-explanatory, but the tool description adds no semantic detail beyond the schema.

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

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

States a specific verb ('Read') and resource ('file contents from OneLake'), clearly distinguishing it from sibling operations like onelake_ls (listing), onelake_write (writing), and onelake_rm (deleting). The action and target are unambiguous.

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

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

The description gives no guidance on when to use this tool versus its siblings. It neither names alternatives such as onelake_ls for listing or onelake_write for writing, nor states any 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 of behavioral disclosure, yet it only states the delete action. It does not disclose that deletion is likely permanent and irreversible, that removing a non-empty directory requires recursive=true, or what happens when the path does not exist. For a destructive tool, these are material 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 a single front-loaded sentence with no wasted words, which is efficient. However, it is under-specified rather than genuinely concise: one sentence is insufficient for a destructive tool with four parameters and zero annotation support.

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 no annotations, no output schema, and 0% schema description coverage, this description is far from complete. It omits recursive semantics, permanence, path formats, and workspace/lakehouse resolution behavior. An agent cannot safely invoke this tool based on this description alone.

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

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

Schema description coverage is 0%, so the description must compensate for the four undocumented parameters, but it adds almost nothing. It does not explain path formats, how lakehouse/workspace resolve, or what the recursive flag does — arguably the most safety-critical parameter since deleting a directory without it will behave differently (or fail).

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 (Delete) and a specific resource (file or directory from OneLake), making the core operation unambiguous. It distinguishes at the operation level from the onelake_ls/read/write siblings, but does not explicitly differentiate from the closely related onelake_delete_shortcut, which is a similar destructive action on a different resource 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?

No guidance is provided on when to use this tool versus alternatives such as onelake_delete_shortcut (shortcuts) or vacuum_delta (delta table cleanup). It also does not mention prerequisites like set_lakehouse/set_workspace or any conditions for when not to use 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?

With no annotations, the description must carry the full behavioral burden, but it only says 'write'. It does not disclose that overwrite defaults to true, how encoding/base64 is handled, or whether workspace/lakehouse selection has side effects.

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

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

The description is a single compact sentence with no filler and is front-loaded with the action. It is efficient for its length, though it sacrifices needed detail for a 7-parameter tool.

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

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

Given 7 parameters, no schema descriptions, no annotations, and no output schema, this description is far from complete. An agent would not know the required target context, overwrite behavior, or parameter roles without opening the schema.

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

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

Schema description coverage is 0%, so the description must compensate, but it only hints at content encoding via 'text or base64'. It provides no meaning for required parameters like lakehouse and path, nor for overwrite, workspace, or encoding defaults.

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

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

The description states a specific action ('Write') and a clear resource ('OneLake'), and it identifies the two supported content forms (text or base64). This distinguishes it from sibling tools like onelake_read and onelake_rm, though it does not mention path/lakehouse context.

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

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

There is no guidance on when to use this tool versus alternatives such as onelake_read or onelake_create_shortcut. The intended use is only implied by the verb 'Write' and the tool name.

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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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?

Tool has no description.

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