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. 'Get' implies a read, but it says nothing about what details are returned, whether authentication or a prior cf_target is required, or how a missing app is 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?

A single, front-loaded sentence with no filler or redundancy. It is efficient, though its brevity borders on under-specification rather than being maximally informative.

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 with no output schema, the description need not enumerate return values, and the schema covers the parameter. Still, with no annotations, it leaves the agent without any prerequisite or safety context.

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

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

Schema coverage is 100% for the single appName parameter, so the schema already defines its meaning. The description adds nothing beyond 'a specific application', which merely restates the parameter's intent. Baseline 3 applies.

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

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

States a specific verb ('Get detailed information') and resource ('a specific application'), and the word 'specific' implicitly separates it from the list-style sibling cf_apps. It does not, however, name cf_apps explicitly, so an agent must infer the single-vs-list 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 is implied: reach for this when you need details on one app rather than a list. There is no explicit when-to-use statement, no mention of the cf_apps alternative, and no prerequisite guidance (e.g., whether an org/space must be targeted first).

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 disclosure burden. It does not state that this is a read-only operation, whether results are paginated, what fields are returned, or that it fails/returns empty when no space is targeted.

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 front-loaded sentence with no filler; the scope qualifier is placed immediately after the verb+resource. Nothing is wasted and nothing is buried.

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

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

For a trivial parameterless list tool with no output schema, the description is barely adequate. It omits the implicit prerequisite (a targeted space) and any indication of what the listing contains, which an agent would need before chaining this with cf_app or cf_target.

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 takes zero parameters, so there is nothing for the description to disambiguate; the schema is trivially complete at 100% coverage. Baseline 4 applies for a parameterless tool.

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

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

States a specific verb and resource ("List all applications") plus the scope ("current space"), so an agent knows exactly what it returns. It does not, however, differentiate itself from the sibling cf_app (singular), leaving the list-vs-detail distinction to be inferred from the names.

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

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

Usage is only implied: the phrase "current space" hints that a space must be targeted first, but the description never states when to use this versus cf_app, cf_spaces, or cf_get_target. No exclusions or prerequisites are given.

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. For a mutating operation it discloses nothing about required permissions, whether the app is restaged/restarted, whether binding is idempotent or errors on an already-bound service, or what the config parameter changes.

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 front-loaded sentence with zero filler, which is appropriately sized for the operation. However, it is so terse that it brushes against under-specification rather than exemplary conciseness.

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 a state-changing bind operation in a 28-tool Cloud Foundry suite, the description is too thin. It omits prerequisites, side effects on the bound app, and error/success behavior that an agent needs to invoke this correctly.

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

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

Schema description coverage is 100%, so all three parameters (appName, serviceName, config) are already documented in the schema. The description adds no additional meaning about how names are resolved or what the JSON config accepts, so the baseline 3 applies.

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

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

The description states a specific verb ('Bind') and both resources ('service instance' and 'application'), so an agent immediately knows the operation. It does not explicitly differentiate itself from the mirror-image sibling cf_unbind_service, but the verb makes the direction 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?

There is no when-to-use guidance, no prerequisites (e.g. must be logged in via cf_login and targeted at an org/space, service instance must already exist), and no mention of alternatives such as cf_create_service. Usage must be inferred entirely from the verb.

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, yet it adds nothing beyond the name: no mention of provisioning being asynchronous/long-running, required permissions, idempotency on duplicate instance names, or that creating may need billing/plan acceptance. For a mutation tool with zero annotation coverage 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 front-loaded sentence with zero waste, but it is sparse to the point of under-specification rather than genuinely economical. Nothing is padded, but nothing is earned either.

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 that performs an org/space-scoped, potentially async mutation, the description omits prerequisites, side effects, and failure modes. With no output schema and no annotations, the description should be doing far more work than it does.

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

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

Schema description coverage is 100%, so all four parameters (service, plan, instanceName, config) are already documented in the schema. The description adds no additional syntax, format, or constraint hints, making the baseline 3 appropriate.

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

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

States a specific verb and resource ('Create a service instance'), which is clearer than a bare name restatement. However, it does not differentiate itself from siblings like cf_bind_service (bind an existing instance) or cf_marketplace (discover services), so an agent must infer the boundary from the tool name alone.

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 on when to use this versus alternatives, and no prerequisites such as needing a targeted org/space (cf_target) or that the service must already exist in the marketplace (cf_marketplace). The agent is left to infer the entire workflow.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a mutation ('Create') but says nothing about required permissions, uniqueness of space names, whether the space becomes the target, or what happens on failure.

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

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

A single short sentence with zero filler and the action front-loaded. It is efficient, though the brevity is partly a symptom of under-specification rather than precision.

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

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

For a mutation tool with no annotations and no output schema, the description is too thin. It omits permission requirements, target-org behavior, and any return information, leaving the agent to guess at operational context.

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

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

Schema description coverage is 100%, so both parameters (org, spaceName) are already documented in the schema, including the default-org behavior for 'org'. The description adds no meaning beyond that, which matches the baseline of 3.

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

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

States a specific verb (Create) and resource (space), so the operation is unambiguous on its own. However, it does nothing to distinguish itself from sibling tools like cf_spaces or cf_create_service, and the description is essentially a restatement of the tool name.

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, nor any prerequisites (e.g., whether cf_login/cf_target must run first). The agent must infer everything 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?

No annotations are provided, so the description carries the full behavioral burden, and 'Delete an application' discloses almost nothing: not that deletion is irreversible, not what the default 'force: true' bypasses in terms of confirmation, and not what happens to bound services or routes. It only conveys the obvious destructive intent.

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 words, front-loaded, with zero waste — but the brevity here is under-specification rather than efficient conciseness for a destructive, no-annotation tool. Every word earns its place only because there is almost nothing to say.

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 an irreversible mutation, the definition should at minimum cover confirmation behavior, reversibility, and side effects on bound services/routes. None of that is present, leaving the agent insufficiently briefed before a destructive call.

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

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

Schema description coverage is 100%, so both appName and the force flag (including its default-true confirmation bypass) are already documented in the schema. The description adds no syntax, format, or effect information beyond the schema, so baseline 3 applies.

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

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

States a specific verb ('Delete') and resource ('application'), so an agent can immediately tell it is a destructive operation on an app rather than a service or route. It does not differentiate itself from the sibling cf_delete_service, but the resource noun makes the target 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?

No when-to-use guidance, no prerequisites (e.g., must the app be stopped or targeted first?), and no pointer to alternatives such as cf_stop or cf_delete_service. The agent must infer everything about context 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?

No annotations are provided, so the description carries the full behavioral burden. It only implies a destructive mutation through the word 'Delete' and does not disclose irreversibility, default confirmation behavior, permission requirements, or what happens to bindings and dependent resources.

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 concise and structurally clean, though extremely terse for a destructive 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 that this is a destructive mutation tool with no annotations and no output schema, the description is too sparse. It states what the tool does but omits critical behavioral context such as irreversibility and default force/confirmation behavior, even though the schema covers the parameters.

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

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

Schema description coverage is 100%, so both instanceName and force are already documented in the schema. The description adds no parameter semantics beyond what the structured input schema provides, making the baseline 3 appropriate.

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

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

States a specific verb and resource: 'Delete a service instance.' This distinguishes it from sibling tools such as cf_delete_app and cf_create_service, since the resource is explicitly a service instance rather than an app or other entity.

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 when-to-use or when-not-to-use guidance, no mention of prerequisites, and no alternatives. The agent is left to infer that this tool is for removing a service instance, which is tautological with 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses the ordered sequence of operations (push, bind, restart), which is real behavioral information beyond the schema. However, it says nothing about permissions required, whether the steps are atomic or partial failures leave the app in an inconsistent state, or whether the restart is conditional.

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 compact sentence that front-loads the composite action with zero filler. It is efficient, though the brevity contributes to the coverage gaps noted elsewhere.

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 multi-step mutation tool with six parameters including a nested env object, no annotations, and no output schema, the description is thin. It omits ordering constraints, failure semantics, and prerequisite state, leaving the agent without enough context to call it confidently in 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 100%, so each of the six parameters is already documented in the schema itself. The description adds no additional meaning about parameter interactions (e.g., how 'services' relates to 'appName', or the effect of 'instances'/'memory' on the push step), so the baseline 3 applies.

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

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

The description gives a specific composite verb sequence — push app, bind services, restart — so the agent knows exactly which operational steps it performs. It does not, however, distinguish itself from simply chaining the sibling tools cf_push, cf_bind_service, and cf_restart, which is the key selection question for a composite 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 on when to use this composite workflow rather than the individual siblings (cf_push, cf_bind_service, cf_restart) that it wraps, nor any prerequisites such as being logged in (cf_login) or targeted (cf_target). The agent must infer usage entirely from 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?

With no annotations, the description carries the full behavioral burden. 'Get all' implies a read-only operation and full retrieval, but it omits permissions required, whether values are masked, and the output format. It provides some transparency but clearly not complete.

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 is front-loaded with the core purpose and contains no wasted words. Perfectly sized for a simple getter.

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 low complexity, full schema coverage, and no output schema, the description is minimally adequate. However, it lacks any behavioral details such as authentication needs or return format, leaving gaps for an agent relying solely on the description.

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

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

Schema description coverage is 100%, so the schema already documents the single parameter (appName). The description adds no additional meaning beyond what the schema provides, fitting the baseline of 3.

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

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

The description states a specific verb ('Get') and resource ('environment variables for an application'), making the tool's function clear. It does not explicitly distinguish itself from sibling tools like cf_set_env or cf_unset_env, but the read verb provides implicit differentiation.

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

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

The description offers no guidance on when to use this tool versus alternatives. It simply states what it does, leaving usage context 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 carries the full burden, but it does establish this is a read operation returning current state rather than a mutation. It says nothing about authentication requirements, failure modes when no target is set, or whether the result is cached/live — modest but non-zero disclosure for a trivial query 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?

One short sentence with the verb and resource front-loaded and the returned fields in a compact parenthetical. No filler, 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?

For a zero-parameter read tool with no annotations and no output schema, the description covers purpose and the shape of the return value well enough to call it correctly. Only the routing guidance against cf_target/cf_login is missing.

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

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

The tool takes zero parameters, so the baseline of 4 applies. The description adds no parameter guidance, which is correct since there is nothing to parameterize.

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 ('Get') and resource ('Cloud Foundry target information') and enumerates the returned fields (API endpoint, org, space, user). The word 'current' signals a read of existing state, which helps separate it from the mutating cf_target sibling, though that contrast is never made 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?

There is no statement of when to call this versus cf_target, cf_login, or cf_orgs/cf_spaces. The read-only nature and 'current' framing imply it is a status check, but the agent must infer that entirely.

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 and largely fails: it does not say that authentication mutates session state, whether credentials are cached/stored or expire, what happens on failure, or that the env-var fallback applies to specific variable names. Only the credential-source fallback is disclosed.

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

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

Two short sentences, zero filler, with the core action front-loaded before the conditional fallback. Nothing is repeated from the schema or title.

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 stateful authentication tool with zero annotations, no output schema, and five optional parameters, the description is thin: it omits which environment variables are consumed, whether a session token is persisted, and how org/space relate to the separate cf_target tool. An agent would need outside knowledge to call this correctly.

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

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

Schema description coverage is 100%, so org, space, password, username and apiEndpoint are already documented in the schema; baseline 3 applies. The description adds only the env-var fallback for the credential parameters, not which variables are read or how org/space interact with targeting.

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 (Authenticate) and resource (Cloud Foundry) with the credential source, so an agent immediately knows this establishes a CF session rather than targeting or listing anything. It does not explicitly contrast itself with cf_target/cf_get_target, but the purpose is unambiguous within the sibling set.

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

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

The second sentence gives a fallback rule — use environment variables when no parameters are supplied — which is real usage guidance. However, it never states when this must be called relative to cf_target or other CF commands, nor any prerequisites (API endpoint required first?), leaving the sequencing to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: no auth/login requirement, no statement of whether logs are streamed, tailed, truncated, or how many are returned. With no output schema either, the return behavior is entirely 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 single phrase is front-loaded and free of padding, but it is under-specified rather than genuinely concise. There is no second sentence to earn its place because no useful detail was provided at all.

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 log-retrieval tool with no annotations and no output schema, the description should explain what is returned (recent vs full logs, format, volume). It leaves all of that unspecified, so an agent cannot predict the result.

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

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

Schema description coverage is 100%, so both appName and recent are already documented in the schema, including the default for recent. The description adds no extra parameter meaning beyond that baseline.

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

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

The description names a specific verb ('Get') and resource ('application logs'), so an agent knows this retrieves log output. It does not distinguish itself from siblings like cf_app or cf_apps, though the resource is distinct enough to infer the difference.

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, nor any prerequisites such as needing a targeted app/org first. The only usage signal comes from the required appName parameter.

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 and discloses nothing: not whether the operation is idempotent, what happens if the route or hostname already exists, what permissions are required, or what the result looks like. It adds no trait beyond what the verb 'map' already implies.

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

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

A single front-loaded phrase with zero waste, which suits a simple tool. It is arguably terse to the point of under-specification, which keeps it short of a 5.

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

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

For a state-mutating tool with four parameters, no annotations, and no output schema, the description is too thin: it omits behavioral expectations, prerequisites, and result semantics. An agent would have to rely almost entirely on the schema and surrounding naming conventions.

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

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

Schema description coverage is 100%, and each parameter has a short inline description, so the schema does the heavy lifting. The description adds no additional semantics (e.g., how path and hostname interact, or whether path should include a leading slash), so the baseline of 3 applies.

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

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

States a specific verb (Map) and resource (route to an application), so the operation is immediately recognizable. It does not explicitly address its counterpart cf_unmap_route, but naming both sides is not strictly necessary here since the verb 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?

There is no guidance on when to use this versus alternatives, nor any mention of prerequisites such as needing a logged-in session, a targeted org/space, or an existing app before the route can be mapped. The agent must infer all of this from the sibling list.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read operation but says nothing about auth requirements, whether results are scoped to the current target, pagination, or output format.

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

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

A single, front-loaded sentence with no filler. It is appropriately terse for a simple list tool, though the brevity borders on under-specification rather than tight structure.

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

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

For a one-optional-param read tool with no output schema and no annotations, the description is minimally adequate but leaves gaps: the dual list/lookup behavior of the 'service' param and any auth or target-scoping context are unaddressed.

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

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

Schema coverage is 100%, so the 'service' parameter and its optionality are already documented, giving a baseline of 3. The description adds no extra meaning and in fact glosses over the notable behavior change: supplying 'service' converts a listing call into a single-service lookup.

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 ('List') and resource ('available services in the marketplace'), so an agent can grasp the intent immediately. However, it does not distinguish itself from the sibling 'cf_services' or 'cf_service', which likely cover overlapping service-listing territory.

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 on when to use this versus cf_services or cf_service, and no mention of prerequisites such as being logged in or targeted at an org/space. The context is only loosely implied by 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?

With no annotations, the description carries the full behavioral burden. 'List all' implies a safe read, but nothing is said about authentication requirements, pagination, ordering, or what an empty result means for a large org list.

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 words, front-loaded with the verb, with zero filler. Nothing could be removed without losing meaning.

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

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

For a zero-parameter, output-schema-less list tool the description is minimally sufficient, but it omits auth prerequisites and any hint about the returned org shape, which matters when the tool is one of many cf_* siblings requiring an authenticated session.

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 declares zero parameters, so the baseline of 4 applies. There is nothing for the description to clarify beyond confirming the tool takes no 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?

States a specific verb and resource ('List all organizations') in a way that is unambiguous despite the opaque tool name cf_orgs. It implicitly separates itself from cf_spaces and cf_apps by naming the org resource, but does not explicitly contrast with any sibling.

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

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

No guidance on when to call this versus alternatives such as cf_target or cf_spaces, or whether authentication/CF login is a prerequisite. The agent must infer usage from context alone.

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

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

No annotations are supplied, so the description carries full behavioral burden. It says 'deploy (push)' but omits side effects, required targeting/auth, whether it creates or updates an app, whether it starts the app by default, or what happens on failure.

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 concise and clear, though its brevity leaves no room for supporting usage or behavioral context.

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

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

For an eight-parameter deployment tool with no annotations and no output schema, the description is far too thin. It lacks usage context, prerequisites, side-effect disclosure, and any distinction from related deployment 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 description coverage is 100%, so all eight parameters are already documented in the input schema. The description adds no parameter meaning beyond what is in the schema, which is the expected baseline when schema coverage is 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?

States a specific verb ('Deploy (push)') and resource ('an application to Cloud Foundry'), so the core action is immediately clear. It does not differentiate from siblings such as cf_deploy_workflow, cf_start, or cf_restart, but the purpose itself 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?

No when-to-use, when-not-to-use, or prerequisite guidance is provided. The description does not mention targeting, authentication, or how this differs from alternative deployment or lifecycle tools like cf_deploy_workflow or cf_start.

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, so the description carries full burden. It says staging re-runs without code changes, which is useful, but doesn't state whether this disrupts running instances, requires a target/org context, or is reversible.

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 tight sentence with the clarifying parenthetical front-loaded after the verb. No waste.

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

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

For a mutation-adjacent operational tool with no annotations and no output schema, the description omits disruption semantics, required context (org/space/target), and differentiation from cf_restart. Too thin given the deployment context.

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

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

Schema coverage is 100% and the single parameter appName is fully described in the schema. The description adds no parameter details beyond that, so baseline 3 applies.

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

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

States a specific verb (restage) and resource (application), and the parenthetical clarifies it means re-running staging without code changes. It doesn't explicitly distinguish from cf_restart, a close sibling, but the mechanism (staging) is clear.

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

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

No when-to-use guidance, no mention of prerequisites, and no distinction from cf_restart or cf_push despite their adjacency. The agent must infer when restaging is appropriate versus a restart or redeploy.

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 carry the full burden of behavioral disclosure. It only states the action, without mentioning side effects (e.g., downtime), required permissions, or whether the operation is safe or reversible. This leaves significant behavioral gaps 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 a single, front-loaded sentence with no wasted words. It is appropriately concise for the information given, though it may be too terse to cover necessary context, which is 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 no annotations, no output schema, and a mutation action, the description is too minimal. It omits prerequisites (e.g., app must exist), side effects, and alternatives, leaving an agent without enough context to invoke it confidently.

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

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

Schema description coverage is 100%, so the single parameter (appName) is already well-documented in the schema. The description adds no additional meaning or constraints beyond what the schema provides, making a baseline score of 3 appropriate.

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

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

The description states a specific verb and resource: 'Restart an application'. It clearly communicates the action and the target. However, it does not differentiate from similar siblings like cf_start, cf_stop, or cf_restage, leaving ambiguity about when this tool is preferred.

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 restart versus alternatives such as cf_start, cf_stop, or cf_restage. There are no conditions, exclusions, or context hints to help an agent choose correctly.

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

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

With no annotations at all, the description carries the full behavioral burden, yet it discloses nothing about side effects: whether scaling restarts instances, whether it requires the app to be targeted/running, whether changes are reversible, or what permissions are needed. For a mutation tool this is a substantial 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 short sentence with the verb and scope front-loaded and zero wasted words. The brevity is appropriate in form, though it reflects under-specification captured in other dimensions rather than genuine density.

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

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

A four-parameter mutation tool with no annotations and no output schema needs the description to explain restart semantics, target-state prerequisites, and partial-update behavior; none of that is present. Only the field list is supplied, which the schema already provides.

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

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

Schema description coverage is 100% and each parameter already carries its own format hint (512M/1G, optionality), so the description's field list adds no meaning beyond the schema. Baseline 3 applies when the schema does the heavy lifting.

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?

Clear verb (scale) plus resource (application) and the three scalable dimensions, which distinguishes it from sibling mutators like cf_start, cf_stop and cf_restart. It does not, however, explicitly contrast itself with any sibling or state what scaling does not cover.

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 guidance: nothing says whether this is for a running vs stopped app, whether it triggers a restart, or when to prefer it over cf_push with different manifest values. The parenthetical only enumerates fields, which is not usage steering.

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. The verb 'Get' implies a read-only lookup, but the description says nothing about permissions, whether it errors on a missing instance, or whether the result size/fields are bounded.

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 front-loaded sentence with no filler or redundancy. It is efficient, though it spends its one sentence on purpose only, leaving no room for the missing usage or behavior context.

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 tool with full schema coverage, this is minimally adequate. With no output schema, though, the description does not hint at what 'detailed information' contains, which would have helped the agent decide whether to call this or a sibling.

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

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

Schema description coverage is 100% and the description adds nothing about instanceName, so the schema already does all the work. With a single fully-documented parameter, the baseline of 3 applies.

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

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

States a specific verb (Get) and resource (detailed information about a service instance), which separates it adequately from the broader cf_services listing. However, it never names or contrasts with the obvious sibling cf_services, so the differentiation is inferred rather than stated.

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 versus cf_services, cf_app, or cf_get_target, nor any stated prerequisite (e.g., a logged-in/targeted session). The agent must infer that this is the single-instance detail lookup by name alone.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only operation ("List") and scopes to the current space, which is useful context. However, it doesn't disclose whether it returns all instances or only bound ones, pagination behavior, or any permissions 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?

A single, front-loaded sentence with zero waste. It directly states the action and scope without extraneous 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 zero-parameter, read-only listing tool with no output schema, the description is nearly complete. It specifies the scope (current space), though it could mention that it lists instances without filtering or that output format is a collection.

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

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

The tool has 0 parameters, so the baseline is 4. The description adds no parameter meaning, but none is needed since the schema is empty and fully described by its absence.

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 (List) and resource (service instances), with scope (current space). However, it doesn't distinguish from siblings like cf_service, cf_marketplace, or cf_create_service, leaving ambiguity about whether this is a read-only enumeration or a management operation.

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 cf_service or cf_marketplace. It implies a listing operation but doesn't state prerequisites (e.g., must be targeted to a space) or contrast with other service-related tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says 'Set' but does not disclose whether an existing value is overwritten, whether a restart is required, whether the change persists, or what permissions are needed. This is a significant gap 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 a single, front-loaded sentence with no wasted words. It is appropriately concise for the action, though it remains minimal given the absence of supporting context.

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 tool with three fully documented parameters and no output schema, the description is minimally sufficient to invoke the tool. However, it omits behavioral context such as side effects and prerequisites, leaving notable gaps for a mutation operation without annotations.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds no additional meaning beyond what the parameter names and schema descriptions provide, making the baseline score of 3 appropriate.

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

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

The description states a specific verb (Set) and resource (environment variable) with the target scope (for an application). It distinguishes the action from sibling tools like cf_get_env and cf_unset_env implicitly, but does not explicitly name or contrast them.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no conditions for use. The description only restates the basic action.

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 supplied, so the description carries the full disclosure burden, and it discloses only the org-scoping. It says nothing about read-only semantics, required authentication/target context, pagination, or what an empty result means for a listing that is inherently dependent on prior cf_target/cf_login 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?

A single front-loaded sentence with no filler or repetition. It is efficient, though the brevity is arguably part of the under-specification problem rather than a virtue on its own.

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 list tool with no output schema, the description is adequate but thin: it does not indicate the shape of the returned space list, nor note that results depend on which org is currently targeted. Nothing an agent needs is outright missing, but nothing extra is provided either.

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 takes zero parameters, which sets the baseline at 4; there is no parameter syntax for the description to clarify. Any parameter documentation would be redundant here.

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 clear verb and resource ('List all spaces') plus a scope qualifier ('in the current organization'), which lets an agent distinguish it from cf_create_space or cf_orgs by name alone. It stops short of explicitly naming any sibling or contrasting itself with them.

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

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

Usage is only implied: the name and the phrase 'current organization' tell an agent this is the read-side counterpart to cf_create_space, but the description never states when to reach for it, what must precede it (a target org), or what the alternative is when a space isn't found.

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

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

With no annotations, the description carries the full behavioral burden but says nothing about whether the operation is asynchronous, whether it waits for the instance to become healthy, required permissions/targeting, or what happens if the app is already running.

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 compact phrase with zero filler and the action front-loaded. It is efficient, though arguably under-specified rather than optimally sized.

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 mutation with no output schema, the essentials (what it acts on) are present, but the result state, targeting requirement, and distinction from cf_restart are missing, leaving the agent to infer the mutation's outcome.

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?

One parameter at 100% schema description coverage, so the schema already explains appName. The description adds no format details (e.g., whether appName is case-sensitive or must exist in the current target), so the baseline 3 applies.

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

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

States a specific verb and resource ('Start a stopped application'), and the qualifier 'stopped' usefully narrows scope versus the sibling cf_restart. However, it does not explicitly differentiate itself from cf_restart/cf_restage, which also bring an app up.

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

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

Usage is only implied by the word 'stopped' – an agent can infer this applies to a non-running app, but there is no explicit when-to-use guidance, no statement of prerequisites (e.g., must be targeted to a space), and no routing to cf_restart as the alternative.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say what stopping does to the app (state transition, process termination), whether it is reversible, whether restarts automatically occur, or whether routes/env are preserved. For an unannotated mutation tool 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 efficient sentence with the verb front-loaded and zero filler. It is perhaps too terse for a state-changing tool, but nothing is wasted.

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

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

The tool is simple (one required string, no output schema), so the description is close to adequate. But with no annotations and no output schema, it should at minimum state the resulting app state or any operational requirement, which it omits.

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

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

Schema coverage is 100% and the single appName parameter is already documented in the schema, so baseline 3 applies. The description adds no extra meaning such as name format, org/space disambiguation, or whether partial names are allowed.

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 (Stop) and resource (running application), which clearly separates it from the sibling cf_start. However, it does not distinguish itself from other lifecycle siblings like cf_restart, cf_restage, or cf_delete_app, leaving the agent to infer the boundary.

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 when-to-use guidance and no alternative named. The adjective 'running' implies a precondition (only running apps can be stopped), but nothing tells the agent when to prefer stop over restart, restage, or delete.

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. 'Switch' implies a mutation of session/target state, but the description never says whether the change persists across calls, what happens if only one of org/space is supplied, or how invalid names 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?

A single short sentence, front-loaded with the verb, with no filler. It is efficient, though it is so terse that brevity shades into under-specification.

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 structurally simple (2 optional flat params, no output schema, no annotations), so little is strictly required. Still missing is the key session-state behavior: what the target becomes when only one parameter is given, or when neither is given.

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

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

Schema description coverage is 100% and both parameters are documented as 'Organization name' and 'Space name', so the schema does the heavy lifting. The description adds no extra semantics, such as whether the values are names vs GUIDs or what the 'and/or' combination implies.

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 ('Switch to') and resource ('organization and/or space'), which is clearly distinguishable from cf_get_target (reads the current target) and cf_login (authenticates). No sibling is named explicitly, 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?

No indication of when to prefer this over cf_login or cf_get_target, nor any prerequisite such as being authenticated or that the org must already exist. The agent must infer usage entirely from the 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?

With no annotations provided, the description carries the full burden of behavioral disclosure and provides none. It doesn't state whether the operation is reversible, whether it requires specific permissions or a targeted org/space, whether the app must be stopped, or what happens to associated service keys or environment variables.

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, front-loaded sentence with no wasted words. It is appropriately sized for the operation, though it is arguably too terse to be maximally helpful.

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 state-mutating operation with zero annotation coverage and no output schema, the description is incomplete. It omits side effects, preconditions, and any note about the inverse relationship with cf_bind_service that would help an agent use it correctly.

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

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

Schema description coverage is 100%, so appName and serviceName are already documented in the schema. The description adds no additional meaning (e.g., naming conventions, whether names must match existing resources). Baseline 3 is appropriate when the schema does the heavy lifting.

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: 'Unbind a service instance from an application'. An agent immediately understands the operation. It does not, however, name or contrast with its sibling cf_bind_service, so the differentiation is left to inference.

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 or prerequisites (e.g., whether the binding must already exist, whether the app must be stopped). Usage is only implied by the verb 'unbind' and the existence of cf_bind_service as the inverse operation.

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 implies a mutation by saying 'Unmap,' but does not disclose permission requirements, whether the route itself is deleted, effects on a running app, idempotency, or reversibility. This is a significant gap for an operation that changes routing 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 a single front-loaded sentence with no wasted words. It is appropriately sized for the minimal information it conveys, though it is arguably under-specified rather than 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?

Given a mutation-style tool with four parameters, no annotations, and no output schema, the description is too thin. It omits required-parameter context, side effects, and any indication of what the operation returns or how errors should be interpreted.

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

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

Schema description coverage is 100%, so all four parameters are already documented by the schema. The description adds no parameter-level meaning beyond the schema, which matches the baseline of 3 when structured fields do the heavy lifting.

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 ('Unmap a route from an application'), which is clear and distinct from the sibling cf_map_route by polarity. It does not explicitly name or contrast with that sibling, but the action is unambiguous from the text alone.

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 preconditions (e.g., route must already be mapped), and no note about the required appName/domain parameters. The agent must infer usage entirely from the name and schema.

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 does not disclose that this is a mutating operation, whether it requires a restart/restage to take effect, what happens if the variable does not exist, or whether the change is reversible. For a mutation tool with zero annotation coverage this is a substantial 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 with no filler, front-loading the action and target. It is appropriately sized, though its brevity is partly under-specification rather than efficient density.

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

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

For a mutation tool with no annotations, no output schema, and a rich sibling set, the description omits the operational context that matters most: whether a restart/restage is needed for the change to apply and how it relates to cf_set_env/cf_get_env. The definition is barely complete enough 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 description coverage is 100%, so both appName and varName are fully documented in the schema. The description adds no format, scope, or side-effect detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb ('Unset') and resource ('environment variable for an application'), which is unambiguous on its own. It does not, however, distinguish itself from the closely related cf_set_env and cf_get_env siblings, so an agent must infer the boundary from the names alone.

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 guidance and no mention of the obvious alternative cf_set_env or cf_get_env. The agent gets no instruction about prerequisites (e.g. an app must exist/target be set) or when unsetting is appropriate versus overwriting with set.

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