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

With no annotations provided, the description carries the full burden and handles it well. It explicitly states 'Side effects: none (read-only)' and discloses that secret-looking keys are masked unless reveal_secrets=True is passed. These are meaningful behavioral traits that go beyond what the schema alone conveys.

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

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

Three short sentences, each earning its place: the core purpose, the read-only side effect, and the secret-handling behavior. The most important action is front-loaded, and there is no filler or redundant repetition of schema information.

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

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

For a two-parameter read-only tool with an output schema, the description is complete. It covers the resource scope, side-effect profile, secret masking behavior, and the key parameter behavior. There is nothing essential missing for an agent to select and call this tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It references the app parameter via 'for a Dokku app' and explains reveal_secrets by describing the masking behavior and its dependency on explicitly passing True. It could be slightly more explicit about the app parameter meaning, but it adds real semantic value beyond the bare schema.

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

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

The description opens with a precise verb and object: 'Get environment config vars for a Dokku app.' This makes the tool's read-only retrieval purpose immediately distinguishable from siblings like set_config and create_app. The scope is clear and specific.

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 signals this is the retrieval tool for app config values, especially with 'Get' and the explicit 'read-only' note. It gives conditional guidance for reveal_secrets, but it does not explicitly name alternatives or state when not to use it, so it falls short of full routing guidance.

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

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

With no annotations present, the description explicitly covers the side-effect profile: 'Side effects: none (read-only).' It also names the exact Dokku command executed, adding transparency about how the result is produced. No annotation contradiction exists because no annotations were provided.

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

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

Three short sentences; purpose is front-loaded, then side effects and implementation. 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 one-parameter, no-nested-output tool, the description covers the core invocation requirements: what it does, that it is safe, and which command it wraps. The output schema covers return structure, so that is not a gap. It could be more complete by routing to siblings, but the core context is sufficient.

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

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

The schema has 0% property descriptions, so the description must compensate. It adds limited meaning by situating the argument as the target Dokku app and showing it as <app> in the command template. It does not explain valid values, formats, or defaults, so the compensation is partial.

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

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

Opens with 'Get domain / VHOST report for a Dokku app,' naming a specific action and resource. This cleanly separates it from siblings like app_report, app_config, or app_url, which target other aspects of an app.

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

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

No guidance is given about when to prefer this tool over siblings such as app_report or app_url. The use case is implied by the domain/VHOST focus, but there are no exclusions, conditions, or alternative tool pointers.

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 burden. It explicitly discloses read-only behavior, states there are no side effects, and reveals a hard 500-line limit—useful operational details not captured elsewhere.

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

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

Two tight sentences deliver purpose, side effects, and parameter constraints. Every clause contributes information, and the key 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 low-complexity two-parameter tool, the description is nearly complete: it covers purpose, side effects, and line limits. It does not explain alternative tools or error/edge cases, but the output schema presumably covers result structure.

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

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

The schema provides parameter names and defaults but no descriptions. The description adds meaning by clarifying that the target is a Dokku app, that lines has a default of 50, and that 500 is an enforced maximum.

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

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

States a specific action and resource: 'Fetch recent logs for a Dokku app.' This clearly identifies what the tool does and distinguishes it from sibling tools focused on configuration or app management.

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 use case is implied through 'Fetch recent logs,' but the description does not explicitly say when to prefer this tool over alternatives or mention any prerequisites or context exclusions. It offers clear context, not explicit selection guidance.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It explicitly declares 'Side effects: none (read-only)' and also reveals the underlying command ('Runs ps:report <app>'), giving useful operational context beyond the schema.

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

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

The description is compact, front-loaded with the main purpose, and every sentence adds value: the purpose, the read-only safety note, and the underlying command. There is no filler or repetition.

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

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

For a simple one-parameter, read-only tool with an output schema available, this description covers the essential facts: what it does, that it is safe, and the underlying command. It could mention using list_apps to discover valid app names, but that is a minor omission.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that 'app' refers to a Dokku app and is used in the command `ps:report <app>`, but it does not elaborate on naming constraints, how to find valid app names, or error behavior for nonexistent apps.

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

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

The description states a specific verb ('Get'), a precise resource ('process report for a Dokku app'), and examples of content ('running state, scale, etc.'). This clearly distinguishes it from sibling tools like app_config or app_logs.

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

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

The description implies when to use it: whenever a process-level report for a Dokku app is needed. However, it does not explicitly compare it to alternatives or state when not to use it, leaving some routing to the agent's inference.

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

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

No annotations are provided, so the description carries the full burden. It explicitly states 'Side effects: none (read-only)' and notes the default scheme, which are valuable behavioral traits. However, it does not disclose error handling, edge cases (e.g., no domains), or return format (though output schema covers that). This is adequate for a simple read-only wrapper but not exhaustive.

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

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

Two sentences with no fluff. The purpose is front-loaded, and the side-effect note and default are stated efficiently. 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 read-only wrapper with an output schema, the description covers purpose, side effects, and scheme default. It lacks explicit usage guidance, but that's a different dimension. The missing edge-case behavior is not critical given the tool's simplicity and the presence of output schema.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the scheme parameter by stating 'defaults to https:// scheme', which adds meaning. The app parameter is not described beyond its name, but it is self-evident from the tool's purpose. Partial compensation, not thorough.

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 purpose: deriving public URLs from domains. It clarifies it's a wrapper over domains:report, which hints at its relationship to lower-level tools, though it doesn't explicitly name sibling alternatives. The purpose is unambiguous and the verb+resource are clear.

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

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

No explicit guidance on when to use this tool versus alternatives like app_domains or domains:report. The phrase 'convenience wrapper' implies it's for convenience, but no conditions, exclusions, or when-not-to-use scenarios 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?

No annotations are provided, so the description carries the full burden. It explicitly discloses the side effect (creates an application on the Dokku host) and the mode requirement, which is essential for a mutating tool. It doesn't discuss duplicate-name behavior or reversibility, but the key mutation and prerequisite are stated.

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

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

The description is three short sentences with the core action first, followed by side effects, a requirement, and a naming constraint. No filler or redundant restatement of the tool name.

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

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

For a single-parameter creation tool, the description provides the essential behavioral context: what it does, what it requires, and the accepted name format. It doesn't cover failure modes or uniqueness rules, but those are not necessary for basic selection and invocation.

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

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

The input schema has no description coverage for the `name` parameter, and the tool description compensates by specifying that app names must be lowercase alphanumeric with optional hyphens. It doesn't explicitly restate that the parameter is the app name, but that mapping is obvious from context.

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

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

The description uses a specific verb (create) with a specific resource (a new Dokku app), making the tool's purpose immediately clear. It is distinct from sibling tools like list, logs, and restart, which handle different operations.

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

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

The description clearly states the prerequisite (DOKKU_MCP_MODE=read-write) and makes the intended operation obvious. It doesn't explicitly enumerate when not to use it or compare to alternatives, but among the given siblings, none are alternatives for creating an app.

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

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

With no annotations provided, the description carries the full burden and does well: it explicitly states 'Side effects: none (read-only)' and discloses behavior regarding DOKKU_APP_ALLOWLIST / DOKKU_APP_DENYLIST filtering. This gives an agent clear expectations beyond the bare operation.

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

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

The description is extremely concise: three short sentences that state purpose, side effects, and filtering behavior. Every sentence adds value, and the read-only note is front-loaded.

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

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

Given the tool's low complexity, zero parameters, and presence of an output schema, the description covers what matters: what it lists, that it is read-only, and how app filtering works. Nothing critical is missing for an agent to invoke it correctly.

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

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

The tool has zero parameters and the schema already covers this completely. Per the baseline rule for 0 parameters, no additional parameter explanation is needed, so the description earns a solid baseline score.

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

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

The description states a clear verb and resource: 'List Dokku apps on the host.' This distinguishes it from app-specific tools like app_report or app_logs by implying a broader listing scope, but it does not explicitly differentiate from siblings or name alternatives.

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

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

No guidance is given about when to choose this tool over app_report, app_config, or other siblings. The read-only nature is stated, but there is no explicit context for when listing is appropriate versus fetching details for a single app.

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?

Since no annotations are provided, the description carries the full burden. It discloses the side effects (downtime possible) and the requirement for confirm=True and read-write mode, which are behavioral details beyond the schema. This is good for a mutation tool, though it could also mention reversibility or specific impact, but the key risks are covered.

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

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

The description is concise, with the main action in the first sentence, followed by critical side effects and requirements in bullet-like lines. Every sentence adds value without redundancy, making it easy to parse quickly.

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

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

Given it's a simple two-parameter tool with an output schema (which handles return values) and no annotations, the description covers the essential behavioral aspects: side effects and prerequisites. It could be slightly improved by noting that the output schema will report the restart status, but that's minor; the description is sufficient for an agent to call correctly.

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

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

Schema coverage is 0%, so the description must compensate. The description provides context that the 'confirm' parameter is required to be true, which adds meaning to the boolean. However, it doesn't describe the 'app' parameter beyond what the schema shows (just a string), leaving the agent to infer it's the app name. Somewhat helpful but not comprehensive.

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 'restart' and the resource 'Dokku app' with context 'all processes'. It distinguishes the tool from siblings like create_app or scale_app, though it doesn't explicitly name a differentiating alternative, but the action 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 implies when to use it (when an app needs restarting) and explicitly states prerequisites (requires read-write mode and confirm=True). It doesn't explicitly state when not to use it or name alternatives, but the prerequisites are clear usage guidance.

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

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

With no annotations provided, the description wisely discloses that the tool changes running process counts and requires a read-write mode plus confirmation. This meaningfully explains the side effects of calling the tool. It does not cover every possible nuance, but the key safety-relevant behavior is explicit.

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 crisp sentences, front-loading the core operation and example, then adding side effects and prerequisites. No filler or repetition exists.

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

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

For a mutating tool with no annotations, the description covers the essential operational context: purpose, parameter format, side effects, and required mode/confirmation. An output schema exists, so return-value details are not necessary. It could be more explicit about what happens to omitted process types, but it is sufficient for correct invocation.

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

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

Schema description coverage is 0%, so the description must add value. It clarifies the scale parameter with the concrete example 'web=2, worker=1' and states that confirm=True is required. The app parameter is minimally but sufficiently identified as the target Dokku app.

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, specific operation: scaling process types for a Dokku app, with the format 'web=2, worker=1'. This is distinct from all sibling tools, none of which perform scaling. The example further clarifies the intended semantics.

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

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

The description gives useful preconditions: DOKKU_MCP_MODE=read-write and confirm=True. However, it does not provide explicit when-to-use or when-not-to-use guidance relative to alternatives like restart_app or set_config. Usage context is mostly implied by the tool's name and purpose.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states side effects (updates environment variables, restarts app unless no_restart=True), prerequisites (read-write mode, confirm=True), and a key behavioral trait (values are never echoed back, only keys). This is exemplary 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 compact and front-loaded: the core action is in the first sentence, followed by three tightly scoped sentences covering side effects, prerequisites, and response behavior. Every sentence earns its place with no redundancy.

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

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

Given the tool's complexity (mutation with side effects, prerequisites, and a nested object parameter), the description covers the critical operational context: side effects, required mode, confirmation flag, and response behavior. It doesn't describe the output schema, but an output schema exists, so that's not required. Minor gap: it doesn't specify what happens if confirm=False, but the default in the schema implies it.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the purpose of 'pairs' (config vars), 'no_restart' (controls restart side effect), and 'confirm' (required for write). It doesn't detail the 'app' parameter, but that is self-evident from the tool's purpose. The description adds meaningful semantics beyond the bare schema.

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

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

The description states a specific verb ('Set') and resource ('config vars on a Dokku app'), and clearly distinguishes this from sibling tools like app_config (which likely reads config) and restart_app (which restarts). The title and description align, and the scope is unambiguous.

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

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

The description implies when to use this tool (to update config vars) and explicitly notes prerequisites (DOKKU_MCP_MODE=read-write and confirm=True). It doesn't explicitly name alternatives or exclusions, but the sibling list and the clear mutation semantics make the usage context clear.

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