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

No annotations are provided, so the description carries the full burden. Calling the feature experimental is the only behavioral disclosure; there is no information about permissions, whether listing has side effects, or whether the cache must be populated first, which is a notable gap for a tool adjacent to a destructive sibling like stellar_cache_clean.

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 that is front-loaded with the verb and resource. It is not padded, though the parenthetical experimental label is slightly buried at the end.

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

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

For a two-parameter, no-annotation, no-output-schema tool, the description covers what the tool does but omits usage context and any behavioral constraints. It is minimally viable but leaves the agent to discover how listing relates to reading.

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 the long and configDir parameters are already documented in the schema. The description adds no parameter-level meaning, making the baseline 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?

States a specific verb (list) and resource (cached actions like transactions and simulations), which is concrete. It does not differentiate from its closest sibling stellar_cache_actionlog_read, leaving the agent to infer the boundary between listing and reading.

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 labels the feature as experimental but provides no when-to-use guidance. It does not mention when to prefer this over stellar_cache_actionlog_read, and no conditions or exclusions 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. It flags the feature as experimental, which is useful, but says nothing about permissions, what happens if the ID is missing, caching semantics, or return shape. For a read tool with zero annotation coverage this is thin.

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 core action front-loaded and a parenthetical caveat. Nothing is wasted, though the sentence is minimal enough that it could have carried one more useful clause.

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 output schema, no annotations, and no explanation of what 'action details' are returned or where the ID comes from, the description leaves notable gaps for a tool whose output is entirely undescribed.

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 there is a single required 'id' parameter already documented as 'ID of the cache entry to read'. The description adds no format or sourcing 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 and resource ('Read cached action details'), and the 'by ID' phrasing distinguishes it from the sibling stellar_cache_actionlog_list. It does not explicitly name the list alternative, but an agent can infer the read-one-vs-list distinction from the resource wording.

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 is given. The description never says when to call this versus stellar_cache_actionlog_list, nor what preconditions (e.g., a prior actionlog list call) exist. Usage is only implied by 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?

No annotations are provided, so the description carries the full behavioral burden. It does disclose the destruction scope (transaction history and contract specs), which is the single most important trait for a destructive tool. However, it says nothing about irreversibility, whether the cache is repopulated automatically, required permissions, or confirmation requirements.

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 sentence, front-loaded with the action and immediately qualified by the exact data affected. 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 destructive, zero-parameter tool with no annotations and no output schema, the description covers what is lost but omits reversibility, whether data can be regenerated, and any confirmation behavior. It is minimally sufficient but leaves real gaps around the risk profile.

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. Baseline 4 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 (cache) and goes further by naming exactly what is removed: transaction history and contract specs. This distinguishes it from cache-read siblings like stellar_cache_actionlog_list and stellar_cache_path, though there is no other destructive cache sibling to contrast with explicitly.

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

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

No guidance on when to run this versus other cache or config tools, and no warning about prerequisites or when it should be avoided. The agent is left to infer that this is a cleanup/reset 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 burden, but 'Show' reasonably conveys a read-only, non-destructive lookup. It does not say whether the directory must already exist, whether the path is created, or what the returned value looks like, though for a trivial zero-param getter these gaps are minor.

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, perfectly sized for a trivial informational tool. Every word 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?

With no output schema, the description does state the essential return value (the cache directory location), and there are no parameters or annotations requiring disclosure. It is nearly complete for a tool this simple, with only the ambiguity around directory existence/creation left open.

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 to document and the baseline of 4 applies. The description correctly introduces no parameter concepts that would need further explanation.

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 (Show) and resource (the cache directory's location), so an agent can tell what it does without opening the schema. It doesn't explicitly distinguish itself from the parallel sibling stellar_config_dir, but the resource name is distinct enough to differentiate in practice.

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 rather than stated: a zero-parameter informational getter is self-evidently used to retrieve the cache path. There is no explicit when/when-not guidance and no mention of the nearby alternatives (stellar_config_dir, stellar_cache_clean, stellar_cache_actionlog_list).

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

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

No annotations are provided, so the description carries the full burden. 'Print' implies a non-mutating, side-effect-free read, but the description never states that it writes to stdout only, that output must be sourced/eval'd, or whether it has any filesystem or config side effects.

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

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

One short, front-loaded sentence with no wasted words. It is appropriately sized for a trivial one-parameter command, though it could have used a second clause to hint at output usage.

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

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

The tool is simple (one enum param, no output schema, no annotations), so a terse description is nearly sufficient. Still, it omits what 'completion code' is and how the caller is expected to consume it, which is the one non-obvious aspect of this command.

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 single parameter is an enum with five allowed values, so the schema fully documents the input. The description adds nothing beyond 'the specified shell', which is the baseline for a fully covered single-param 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 ('Print') and resource ('shell completion code') plus the scope ('for the specified shell'). It is clearly distinguished from the many sibling tools, none of which generate completion scripts, though it does not explicitly call that difference out.

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 mention of typical workflow (e.g. redirecting or eval'ing the output into the current shell). The agent must infer usage 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?

No annotations are provided, so the description carries the full burden. 'Show' implies a read-only operation and it states that both location and contents are displayed, but it omits any mention of permissions, side effects, or whether the directory is created if absent. It adds modest behavioral 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?

One sentence, front-loaded with the action and object, with no wasted words. Appropriate for a simple read tool.

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

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

The tool is simple and the single parameter is fully documented in the schema. The description covers the primary output (location and contents) and no output schema exists, so it is largely sufficient, though it could note read-only safety.

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 optional configDir parameter is fully documented there, including the XDG default. The description adds no extra syntax or meaning 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 ('Show') and resource ('global configuration directory location and contents'). It is clear what the tool does, but it does not explicitly differentiate itself from sibling config tools like stellar_config_migrate.

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

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

No when-to-use or when-not-to-use guidance is provided, and no alternatives such as stellar_config_migrate are mentioned. The agent must infer usage 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 provided, so the description carries the full burden. It doesn't say whether migration is destructive, what happens if the global directory already has a config, what gets copied vs moved, whether permissions are required, or whether the operation is reversible. For a mutation tool this is a serious 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?

Single concise sentence, front-loaded with the verb. No waste, though it is minimal to the point of under-specification rather than ideal 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?

For a filesystem mutation tool with no annotations and no output schema, the description omits consequences (overwrite behavior, reversibility, failure modes). It is not adequate to invoke safely without additional assumptions.

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% – the configDir parameter has a full description of default resolution. The tool description adds no parameter detail beyond the schema. Baseline 3 applies when schema fully documents the parameter.

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

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

States verb 'Migrate' and resource 'local configuration', and identifies source/destination ('local' to 'global directory'). However, it doesn't distinguish from sibling stellar_config_dir, which presumably shows the config location, nor do the terms 'local' and 'global' get defined. Purpose is graspable but sibling differentiation is absent.

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., whether an existing global config is overwritten), no warnings about irreversible migration. An agent cannot infer when this tool is appropriate vs stellar_config_dir.

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 says 'running' container, implying a precondition, but doesn't disclose whether logs are streamed, tailed, or a one-shot snapshot, whether output is paginated, or what happens on a stopped/absent container.

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. Every word earns its place and the resource/verb lead the phrase.

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

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

There is no output schema and no annotations, so the description should carry more weight. For a log tool, the agent would benefit from knowing the return shape (e.g., log lines, streaming vs snapshot) and error behavior, none of which is provided.

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 (name with a local default, dockerHost override) are fully documented in the schema. The description adds no meaning beyond that, 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 (get) and resource (logs from a network container), making the operation immediately clear. It implicitly differentiates from the container lifecycle siblings (stellar_container_start/stop) by scoping to log retrieval, though it doesn't name those siblings explicitly.

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

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

Usage is only implied — an agent would use it to inspect a container's logs — and the qualifier 'running' hints at a precondition (container must be up). There is no explicit when-to-use guidance, no mention of alternatives, and no statement about what to do if no container is running.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses which components are launched (node, RPC, API, faucet), which is genuine context, but says nothing about it being a long-running process, required Docker availability, port binding conflicts, resource limits, or whether the call blocks — all material for a container-start 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?

A single front-loaded sentence with zero filler; the action and the components affected come first. Nothing to trim.

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

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

With no annotations and no output schema, the description should cover more of the lifecycle, e.g. that a stopped container is cleaned up via stellar_container_stop or that logs come from stellar_container_logs. The core purpose is covered and defaults live in the schema, but the post-start workflow is left implicit.

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

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

Schema description coverage is 100%, so every one of the 7 parameters is already documented in the schema (including the network enum default of local). The description adds no format or constraint detail beyond what the schema supplies, 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?

Specific verb (start) plus resource (container running a Stellar node, RPC, API, friendbot), which immediately distinguishes it from the sibling stellar_container_stop. It doesn't explicitly name the stop tool as its counterpart, but the action direction 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 guidance, no prerequisites, and no mention of alternatives such as stellar_network_use or stellar_network_add for non-container workflows. The agent must infer that this spins up a dockerized local/dev network rather than joining an existing one.

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

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

No annotations are provided, so the description carries full behavioral disclosure burden. It does not state whether stopping is reversible, what happens to container state or data, whether the operation is idempotent, or what permissions are required. The only behavioral context added is that the container should have been started via the corresponding start 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 zero filler. It states the action and lifecycle relationship immediately.

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

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

For a simple two-parameter stop tool with a fully described schema and no output schema, the description is minimally adequate. However, with no annotations and no output schema, it omits operational details such as idempotency and side effects, leaving a clear gap in behavioral completeness.

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

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

Schema description coverage is 100%, and both optional parameters are already documented in the schema, including the 'name' default of 'local' and the 'dockerHost' override. The description adds no parameter-specific semantics beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description provides a specific verb and resource ('Stop a network container') and explicitly ties it to the lifecycle counterpart ('started with stellar container start'). This clearly distinguishes it from sibling tools such as stellar_container_start and stellar_container_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 a prerequisite container must have been started, but it gives no explicit when-to-use guidance, no when-not-to-use guidance, and no alternatives for inspecting or restarting containers. The agent is left to infer the usage context.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not state that this is a stateful mutation operation (for add/remove), nor does it explain the implications of the overwrite parameter, potential side effects, or return format. The description is silent on all behavioral aspects.

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

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

The single-sentence description is concise and front-loaded, with no wasted words. However, its brevity comes at the cost of omitting essential details, so it is not maximally effective.

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

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

For a tool with five parameters, no annotations, and no output schema, the description is incomplete. It does not name the supported actions, explain the action-driven behavior, clarify required parameters, or describe how aliases persist or interact with networks, leaving significant gaps 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 100%, so all five parameters are fully documented in the schema itself. The description adds no parameter-level meaning beyond what the schema provides, which meets the baseline expectation for high coverage.

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

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

The description states a clear verb and resource ('Manage contract aliases') and specifies the benefit ('for easier reference'), which is more specific than the name alone. However, it fails to differentiate this tool from its many siblings in the Stellar family and does not reveal that the tool is actually a multi-action dispatcher supporting add, remove, show, and list.

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

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

No guidance is provided on when to use this tool versus alternatives. It is unclear when an agent should create an alias, and no prerequisites (such as a contract being deployed) or relationships to sibling tools like stellar_contract_deploy are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It says 'Deploy' (a mutation) but gives no details about submission, fee requirements, account prerequisites, irreversibility, or the effect of the build_only parameter. This is a significant gap for a write 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 a single front-loaded sentence with no wasted words. It is efficient, though its brevity leaves behavioral gaps that a longer description could address.

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

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

Given the complexity of deploying a Stellar Asset Contract, the absence of annotations and an output schema, the description is incomplete. It does not explain key behavioral aspects such as transaction submission, required account state, or return values—context an agent would need to invoke the tool correctly.

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

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

Schema description coverage is 100%, so all six parameters are documented in the schema. The description adds no parameter-level information, making the baseline 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 (Deploy) and a specific resource (Stellar Asset Contract for wrapping classic assets). This distinguishes it from the generic sibling stellar_contract_deploy, which deploys contracts without the asset-wrapping focus.

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

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

The phrase 'for wrapping classic assets' implies the use case—when you need to wrap a classic asset into a contract. However, it gives no explicit when/when-not guidance or alternatives, so usage is only implied.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it does not say that this writes files to disk, what happens when output_dir already exists (the overwrite param hints at it but the risk is undisclosed), or whether it hits the network. For a filesystem-writing generation tool this is a notable 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 tight sentence with the verb and resource front-loaded and no wasted words. It is not padded, though it is arguably too short given the tool's 7 parameters.

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

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

With 7 parameters, no output schema, and no annotations, the description should clarify the wasm-vs-(contract_id+network) input paths, the required language, and the output destination behavior. As written it leaves the agent to reconstruct the invocation from the schema alone.

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

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

Schema description coverage is 100%, so every parameter is already documented in the schema; the description adds no syntax, format, or usage guidance beyond 'various languages'. 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?

States a specific verb and resource ('Generate client bindings') plus scope ('for a contract in various languages'), which is enough to distinguish it from siblings like stellar_contract_build or stellar_contract_deploy. It does not, however, name or contrast any sibling explicitly.

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

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

No when-to-use, prerequisites, or alternatives are given. An agent must infer that this is a post-build step and that the contract source comes from either a WASM file or a contract_id on a network.

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 says nothing about the fact that this invokes cargo, writes WASM artifacts to disk, copies files to out_dir, can be long-running, or that print_commands_only makes it a dry run. The only behavioral hint is 'from Rust source code'.

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 and no redundancy. It is efficient, though the extreme brevity leaves it under-specified rather than optimally structured for a 9-parameter tool.

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

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

For a mutating build tool with 9 parameters, a nested meta object, no annotations, and no output schema, the description omits output/artifact behavior, dry-run semantics, and toolchain requirements. An agent cannot tell what it gets back or what side effects occur.

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% across all 9 parameters, so the schema already explains package, profile, features, manifest_path, out_dir, etc. The description adds no extra meaning (e.g. that meta keys are injected as env vars or that the WASM build target is wasm32-unknown-unknown), 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+resource ('Build a Soroban contract') plus the input modality ('from Rust source code'), so the agent knows exactly what it produces. It does not differentiate from nearby siblings such as stellar_contract_optimize or stellar_contract_deploy, which also act on built contracts.

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. 'run after stellar_contract_init, before stellar_contract_deploy/optimize'), and no mention of alternatives. The agent must infer ordering from the tool name alone.

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

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

No annotations are supplied, so the description carries the full behavioral burden, and it says almost nothing: it doesn't disclose that this submits a real transaction, spends fees, is irreversible on mainnet, or that ignore_checks bypasses safety validation. Marking a tool that can touch mainnet with public funds this tersely 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 filler. It is efficient, though arguably under-specified rather than optimally sized for a 10-parameter mutation 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?

With 10 parameters, no annotations, and no output schema, the description should carry real weight, but it supplies none of the missing context about cost, irreversibility, prerequisites, or the wasm_path/wasm_hash relationship. Adequate only as a label, not as invocation guidance.

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 every one of the 10 parameters is already documented in the schema and the baseline is 3. The description adds no format, default, or constraint detail beyond what the schema provides.

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) and resource (Soroban smart contract) plus the target network, which separates it from siblings like stellar_contract_build, stellar_contract_upload, and stellar_contract_asset_deploy (the latter deploys an asset, not a Soroban contract). It never explicitly names those siblings as alternatives, so the differentiation is implicit 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 deploy versus build, upload, or optimize first, nor any mention of the wasm_path vs wasm_hash choice or the build_only workflow. The agent is left to infer the entire deployment pipeline ordering from sibling names 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 of behavioral disclosure. It implies a mutation ('Extend') but fails to mention that this typically submits a transaction, requires a source account, incurs fees, or can be used with build_only/ttl_ledger_only flags visible in 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 a single, front-loaded sentence with no wasted words. It is appropriately sized for a concise statement of purpose, though its brevity contributes to gaps 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?

For a tool with 10 parameters, no annotations, no output schema, and many sibling tools, the description is far too sparse. It omits when to use the tool, how it interacts with required parameters like network and source_account, and what behavioral differences exist between normal submission and build_only/ttl_ledger_only modes.

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 every parameter already has documentation within the input schema. The description adds no additional parameter semantics, making the baseline 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 ('Extend') and resource ('time-to-live of contract data entries'), so the tool's purpose is clear. However, it does not differentiate itself from related sibling tools such as stellar_contract_restore or stellar_contract_read, which might also manipulate contract data state.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention prerequisites, network context, or transaction-submission implications. It simply states the action, leaving the agent to infer usage from the schema alone.

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

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

With no annotations provided, the description carries the full disclosure burden. 'Fetch' implies a read, but it says nothing about what happens when out_file is omitted (returned inline vs. only written to disk), error behavior for unknown contracts, or network/config requirements — significant gaps for a tool with zero annotation coverage.

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, front-loaded with verb and resource, with no redundant restatement of the name or title. It is efficient, though terse enough to leave real questions unanswered.

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

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

There is no output schema, so the description should clarify return behavior — particularly whether the WASM is returned as data or only written when out_file is supplied. For a simple read tool with fully-covered parameters, it is adequate but leaves that one meaningful ambiguity unresolved.

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 are already documented in the schema (contract_id, network enum, out_file path). The description adds no format or syntactic detail beyond that, which is the expected baseline 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?

States a specific verb (fetch) and resource (contract WASM binary) with its source (network), which cleanly separates it from siblings like stellar_contract_upload, stellar_contract_read, and stellar_contract_info. It does not, however, explicitly name those siblings or contrast 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?

No guidance on when to use this versus alternatives such as stellar_contract_read or stellar_contract_info, and no prerequisites (e.g. network config, contract must exist). 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?

No annotations are provided, so the description carries the full behavioral burden. It says 'generate' but never discloses whether this is deterministic, purely offline, whether it touches the network, or what permissions/network access it requires — meaningful gaps for an agent deciding whether to call it.

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, front-loaded with the verb and resource. No waste, though it is arguably under-specified rather than truly 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?

With five parameters, conditional requirements (salt and source_account required for wasm), no output schema, and no annotations, the description is too thin. It does not explain the conditional parameter interactions or what the generated ID looks like.

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

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

Schema description coverage is 100%, so the schema already documents id_type, network, salt, asset, and source_account. The description only restates the asset/WASM split already encoded in the id_type enum, adding no format or dependency detail beyond the schema.

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

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

Specific verb 'Generate' plus resource 'contract IDs' with the two variant families (assets vs WASM) named. It clearly differs from deployment siblings like stellar_contract_deploy or stellar_contract_asset_deploy, though it never explicitly contrasts 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?

The description states what it produces but gives no guidance on when an agent should compute a contract ID rather than deploy, alias, or read a contract. No prerequisites or workflow context are offered.

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

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

With no annotations provided, the description carries the full behavioral burden. It does not disclose whether this is a read-only operation, what permissions or network context is required, whether it has side effects, or what the response contains beyond generic 'information'.

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

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

The description is a single efficient sentence with no filler. It is front-loaded with the main action and resource, though the trailing 'etc.' is vague and adds little.

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 six-parameter tool with no annotations and no output schema, the description is too thin. It does not explain return values, output formats, or how to interpret the different info_type values, leaving the agent without enough context to use it confidently among many sibling contract tools.

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

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

Schema description coverage is 100%, so the input schema already documents all six parameters, their enums, and descriptions. The description adds only the examples 'interface' and 'metadata', which partially map to the info_type enum but do not significantly extend schema semantics.

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

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

States a clear verb (Get) and resource (contract) with example information types (interface, metadata), so an agent can understand the basic purpose. However, it does not distinguish this tool from siblings like stellar_contract_read, stellar_contract_fetch, stellar_contract_id, or stellar_contract_bindings, and the 'etc.' makes the scope somewhat vague.

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 guidance, prerequisites, or alternatives. It does not explain when an agent should choose this tool over closely related contract tools such as read, fetch, bindings, or id.

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 doesn't disclose that this is a file-creating mutation, what files/directories get scaffolded, whether it fails on an existing directory, or whether permissions/network setup are needed. The 'overwrite' param hints at destructive overwrite behavior, but the description itself says nothing.

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, which is good. However, it is under-specified rather than genuinely concise – it has been trimmed past the point of usefulness for a scaffolding mutation.

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 file-creating tool with no annotations and no output schema, the description is too thin: it omits what the scaffold produces, directory side effects, and success/failure conditions. Parameter coverage is complete, but the behavioral picture an agent needs before running a write operation is not.

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 (name, overwrite, project_path) are already documented in the schema. The description adds no format, default, or constraint detail beyond that, 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 ('Initialize') and resource ('Soroban contract project'), so the agent knows this scaffolds a new project. It does not differentiate from siblings such as stellar_contract_build or stellar_contract_deploy, which also operate on contract projects.

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

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

No indication of when to use this versus alternatives, no prerequisites (e.g., whether a network must be configured first), and no note that it should only run for new projects. 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?

No annotations are provided, so the description carries the full burden. It only states the action without disclosing critical behavioral traits: whether this requires signing, what happens on failure, whether it sends a transaction by default, or the implications of parameters like 'send' or 'build_only'. 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, clear sentence that is front-loaded with the core action and resource. It is appropriately sized and contains no wasted words.

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

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

Given the tool's complexity (8 parameters, mutation operation, no annotations, no output schema), the description is inadequate. It should explain return values, side effects, and key behavioral aspects like transaction sending and simulation options to be complete.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters, including enums and nested objects. The description adds no parameter information beyond what the schema provides. Baseline 3 is appropriate when 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 ('Invoke') and resource ('a function on a deployed Soroban contract'), which clearly conveys the tool's purpose. It distinguishes itself from siblings like stellar_contract_deploy and stellar_contract_read by focusing on function invocation, though it doesn't explicitly 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?

The description provides a basic indication of when to use this tool (invoking a function on a deployed contract), but it does not specify when to use it versus alternatives such as stellar_tx_simulate or stellar_contract_read, nor does it mention prerequisites like contract deployment.

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. 'Optimize' implies a transformation that likely writes an output file, but the description does not state whether files are modified in place, what defaults apply, whether the operation is reversible, or what permissions or prerequisites are needed.

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

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

The description is a single, front-loaded sentence with no filler. It is appropriately concise for its length, though it could be considered under-specified rather than optimally sized for a mutating file operation.

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 appears to be a transformation tool with no annotations, no output schema, and only two parameters, the description is too thin. It omits critical behavioral context such as what optimization entails, whether it modifies originals, how output paths are handled, and when in a contract workflow it should be invoked.

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 input schema already documents both parameters, including the default output suffix for wasm_out. The description adds no additional parameter meaning, so baseline 3 is appropriate.

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

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

States a specific verb ('Optimize') and resource ('WASM files'), and adds the deployment context. However, it does not explicitly differentiate this tool from siblings like stellar_contract_build or stellar_contract_deploy, which an agent might reasonably confuse it with.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor does it state prerequisites or exclusions. The phrase 'for deployment' implies a workflow context but does not specify when optimization is required or how it relates to build/deploy steps.

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 behavioral burden. It says nothing about read-only safety, whether it performs network calls, error behavior, or what a successful read returns. The single sentence adds no behavioral context.

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

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

The description is a single short sentence with no wasted words, but it is under-specified rather than concise. It is front-loaded but lacks any structure beyond the bare purpose.

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

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

For a tool with six parameters and no output schema or annotations, the description is inadequate. It does not explain return format, how to choose between key and key_xdr, or what happens on failure. An agent would need to infer behavior entirely from the schema.

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

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

Schema description coverage is 100%, so all six parameters (key, key_xdr, network, durability, output, contract_id) are already documented in the schema. The description adds no additional parameter meaning, which is acceptable given the high schema coverage.

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

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

The description 'Read contract data entries' restates the tool name with a generic verb+resource. It does not distinguish this tool from siblings like stellar_contract_fetch, stellar_contract_info, or stellar_contract_extend, which all relate to contract data.

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

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

There is no guidance on when to use this tool versus alternatives such as stellar_contract_fetch or stellar_contract_info. No exclusions, prerequisites, or context 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 behavioral burden. It implies a write/mutation operation but does not disclose permissions needed, whether the restoration is immediate or requires submission, or what happens to ledger TTLs without additional options.

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 efficient, though its brevity borders on under-specification for a 10-parameter tool.

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

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

The tool has 10 parameters, no annotations, and no output schema, so the description should explain more about behavior, side effects, and required context. A single sentence is not complete enough for a complex contract data restoration operation.

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

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

Schema description coverage is 100%, so every parameter is already documented in the input schema. The description adds no additional meaning beyond the schema, 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?

States a specific verb (restore) and resource (evicted contract data entries). This distinguishes it from read/fetch/upload siblings, but it does not explicitly differentiate from stellar_contract_extend, which also deals with contract data persistence.

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 tool versus alternatives such as stellar_contract_extend or stellar_contract_fetch. The description does not state prerequisites (e.g., evicted entries must exist) or when restoration is appropriate.

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

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

No annotations are provided, so the description carries the full burden. It says nothing about permissions/authorization, whether the upload is idempotent or returns a WASM hash, or that 'build_only' turns this into a dry run and 'ignore_checks' bypasses safety checks. For a ledger-mutating tool with no 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. The scope distinction is placed immediately after the action.

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

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

For a six-parameter mutation tool with no annotations and no output schema, the description omits the behavioral impact of build_only and ignore_checks and says nothing about the result of a successful upload. It is under-specified relative to the tool's complexity.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters, including build_only, ignore_checks, fee, and network enum. The description adds no parameter meaning beyond what the schema provides, making the baseline 3 correct.

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 (upload) and resource (WASM file) with an explicit scope qualifier ('without creating a contract instance') that cleanly separates it from stellar_contract_deploy. An agent can distinguish it from the deploy sibling without opening either schema.

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

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

The phrase 'without creating a contract instance' implies the deploy alternative but never names it or states when each is preferred. Usage is inferable rather than explicit, which is minimum viable.

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 behavioral burden. It does not state whether the tool is read-only or safe, whether it mutates config, what specific checks it performs, or what the output looks like — a significant gap for a diagnostic command.

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 with the action front-loaded. No filler, though it is arguably too terse given the missing 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?

With no annotations and no output schema, the description is the only source of behavioral information, and it is thin. It is minimally adequate for a zero-required-parameter diagnostic tool but leaves unclear what problems it detects or what it reports back.

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

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

The single optional parameter (configDir) is fully documented in the schema at 100% coverage, so the baseline is 3. The description adds no meaning beyond the schema, but none is needed 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 specific verb and scope ('diagnose and troubleshoot CLI and network issues') with a qualifier about what it looks for ('common problems'). The purpose is clear, but it does not differentiate itself from neighboring diagnostic tools like stellar_network_health or stellar_network_info.

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

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

No guidance on when to reach for this tool versus the many network/config siblings. 'Troubleshoot' implies a context, but there are no explicit triggers, prerequisites, or alternatives named.

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 implies read-only printing but does not state the source of the variables (.env file on disk vs process environment), whether secrets such as account keys can be exposed, or how configDir affects the output. That is a meaningful gap for a tool that may surface sensitive values.

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, front-loaded with the primary action and the secondary mode. Nothing is wasted, though the dual-purpose phrasing is slightly compressed relative to what it needs to convey.

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

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

For a simple two-optional-parameter, no-output-schema tool, the description is close to adequate. However, it leaves open whether printed variables can include secrets and where they are read from, which matters for correct and safe invocation.

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

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

Schema description coverage is 100%, so both parameters are already documented, and the description adds no syntax, format, or defaulting detail beyond what the schema provides. 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?

States specific verbs (print/get) and resource (environment variables) and distinguishes the two modes (bulk dump vs single value). It does not differentiate itself from any sibling, though none of the listed siblings are env-var tools, so the risk of confusion is low.

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 two modes are implied by the description ('or get specific variable value'), letting an agent infer that omitting 'name' dumps everything and supplying it fetches one value. There is no explicit when-to-use guidance, no mention of where the variables are sourced from, and no alternatives named.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says 'watch', which implies monitoring, but does not explain whether the tool streams continuously, polls, blocks, paginates, or terminates after a default count of events. Given 12 optional parameters including count and cursor, the ambiguity is significant.

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 clause with no filler or redundancy. It is appropriately concise for the surface-level purpose statement, though other dimensions suffer from the brevity.

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

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

This is a complex 12-parameter tool with no annotations and no output schema. The description does not explain return format, pagination or streaming behavior, default output, or required network/config context, leaving substantial gaps for an agent to infer.

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 input schema already documents all 12 parameters in detail. The description adds no additional meaning beyond what the schema provides, which is the baseline expectation when schema coverage is high.

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 (watch) and resource (contract events). It is clear enough to identify the tool's main function, but it does not distinguish this tool from adjacent siblings such as ledger_fetch or contract_read, nor does it describe the scope of the watch (e.g., live stream vs. paginated event query).

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

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

No explicit guidance on when to use this tool versus alternatives, nor any when-not conditions. The only implied usage is watching contract events, with no mention of prerequisites, network context, or how to choose among event-related siblings.

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

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

No annotations exist, so the description carries the full disclosure burden. "Fetch" implies a read, but nothing is said about rate limits, caching, freshness, required network configuration, or whether fee data is network-wide vs. per-operation — all material for a planning 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?

A single front-loaded sentence with no filler; the purpose clause is stated before elaboration. Efficient, though extremely brief for the scope of the 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?

With no output schema and no annotations, the description should clarify what 'fee statistics' contains (base fee, priority fee, surge pricing) and that network/endpoint are selectable. It gives just enough to call the tool but leaves return-shape expectations unset.

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% across all 5 parameters, so the schema already documents output format, rpcUrl, network, rpcHeaders, and networkPassphrase. The description adds no parameter-level meaning beyond that, which is the baseline-3 case.

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 (Fetch) and resource (network fee statistics), and frames the intent (transaction planning and cost estimation). No sibling tool covers fees, so differentiation is implicit rather than stated, keeping it short of a 5.

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

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

"For transaction planning and cost estimation" gives a plausible use context, but there is no explicit when-to-use/when-not guidance and no named alternative for related queries such as network health or ledger data.

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 is a mutation tool (creates/stores a keypair) yet says nothing about permissions, whether it overwrites an existing identity, or that it triggers interactive prompts for secretKey/seedPhrase. The interactive nature is only implied by the schema, not the description.

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

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

A single short phrase, front-loaded with the verb and resource. The parenthetical is terse to the point of being cryptic about the ledger/secure-store options but costs little.

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 six-parameter creation tool with no annotations and no output schema needs the description to explain side effects, prompting, and storage behavior. The description supplies none of this, leaving significant gaps for safe invocation.

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

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

Schema description coverage is 100%, so each of the six parameters is already documented in the schema. The description adds no extra meaning (e.g. how publicKey vs secretKey vs seedPhrase interact, or what configDir accepts), 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 (add) and resource (identity/keypair), with a parenthetical hinting at the storage backends. However it does not differentiate itself from close siblings like stellar_keys_generate or stellar_keys_use, leaving the agent to infer the distinction.

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

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

No indication of when to use this versus stellar_keys_generate, stellar_keys_use, or stellar_keys_secret. No prerequisites, no note about whether an identity must already exist or whether this overwrites one.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the test-network restriction, which is a meaningful behavioral constraint, but says nothing about the funding mechanism (e.g., friendbot), idempotency, rate limits, or what changes on the network as a result.

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

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

A single short sentence with zero waste and the key constraint front-loaded. It is arguably too terse rather than padded, but it is structurally clean.

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

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

For a mutation-style tool with 7 parameters, a nested object, no annotations, and no output schema, the description omits critical context: where funds come from, whether the call can fail on live networks, and what the caller should expect. It is incomplete for the tool's complexity.

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

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

Schema description coverage is 100% with 7 documented parameters, so the schema already explains each field. The description adds no parameter-level 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?

States a specific verb ('Fund') and resource ('identity') and scopes it to a test network, which is more specific than the bare name. It does not differentiate itself from sibling key tools like stellar_keys_generate or stellar_keys_add, but the purpose is unambiguous.

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

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

The phrase 'on a test network' implies this only applies to test networks, giving an implicit usage condition. However, it names no alternatives (e.g., what to do on mainnet), no prerequisites, and no when-not-to-use guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses almost nothing. It does not explain that an identity is created/persisted, whether an existing identity is overwritten by default, that funding may hit a network, or what happens if a name already exists. For an 11-parameter mutation tool with no annotations, this is a severe 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 that front-loads the action and the key default (24-word seed phrase). It is concise but under-specified rather than overly trimmed for such a complex 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?

For a 11-parameter, mutation-oriented tool with no annotations and no output schema, the description is far too thin. It omits prerequisites, persistence/overwrite behavior, funding side effects, and return information, leaving major gaps an agent needs to call it safely.

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 11 parameters is documented in the schema and the baseline is 3. The description adds the 24-word seed phrase detail but does not explain interactions between parameters (e.g., seed vs. hdPath, network vs. rpcUrl, overwrite implications).

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 (Generate) and resource (new identity) with a concrete detail (24-word seed phrase), so purpose is clear. However, it does not differentiate itself from siblings like stellar_keys_add, stellar_keys_use, or stellar_keys_secret, which all touch the same identity/keys domain and could be confused with generation.

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

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

There is no guidance on when to use this tool versus alternatives such as stellar_keys_add (adding an existing key) or stellar_keys_use (switching active identity). The agent must infer the correct context from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden, yet it discloses nothing about behavior. It does not confirm this is a read-only operation, nor does it describe output format, ordering, or whether secrets are ever exposed.

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?

At two words it is maximally front-loaded and wastes nothing, but the brevity reflects under-specification rather than disciplined editing.

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

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

For a tool with no annotations and no output schema, the description should convey what is returned and the read-only nature of the operation. Neither is present, leaving meaningful gaps for the agent.

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

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

Schema description coverage is 100%, with 'long' and 'configDir' both documented in the schema, so the baseline is 3. The description adds no meaning beyond the schema.

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

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

States a specific verb ('List') and resource ('identities'), so the agent knows it enumerates stored keys. However, it offers no differentiation from siblings like stellar_keys_public_key or stellar_keys_secret, which an agent may confuse with it.

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 use this tool versus alternatives such as stellar_keys_public_key or stellar_keys_secret. The agent must infer usage purely 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?

No annotations are provided, so the description carries the full behavioral burden. Beyond being a lookup, it says nothing about what happens if the named identity doesn't exist, whether it requires an unlocked/configured wallet, or what form the returned key takes.

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 with no waste, but it is arguably under-specified rather than optimally concise given the missing usage and 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 zero-required-parameter read tool this is close to adequate, but with no annotations and no output schema the description should at least say the return is a public key string and what happens on lookup failure.

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 name, hdPath, and configDir and their defaults. The description adds nothing 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 and resource: given an identity, returns its public key address. This distinguishes it from siblings like stellar_keys_secret (which returns a secret key), though it never names that sibling explicitly.

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

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

No guidance on when to use this versus stellar_keys_list, stellar_keys_secret, or stellar_keys_use. The agent gets no context about prerequisites (e.g. whether the identity must already be configured).

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 provided, so the description carries the full burden. It says 'Remove' but doesn't disclose whether deletion is permanent, whether the key can be recovered, or what happens to config state. A destructive operation of this kind needs that context.

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

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

Three words, perfectly front-loaded and waste-free. Brevity here edges toward under-specification rather than padding, but structure is clean.

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

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

Two-param mutation tool with no annotations, no output schema, and a description far too thin to explain consequences. An agent knows it removes an identity but not what that entails.

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 both 'name' and 'configDir' adequately. Baseline 3 applies; description adds nothing beyond the resource name.

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 (Remove) and resource (identity), which is clear enough. But it's minimal and doesn't distinguish from sibling stellar_keys_secret or stellar_keys_use, nor mention it removes keys from stored config.

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, no warning about irreversibility, and no routing to sibling tools like stellar_keys_list to find names. Siblings stellar_keys_add/generate exist, implying this is the inverse, but that's inferred not stated.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not mention that this exposes sensitive secret material, any security implications, required permissions, or side effects. This is a significant gap for a tool that outputs secret keys.

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 tool's complexity.

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

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

Given the tool outputs secret keys and has no annotations or output schema, the description is insufficient. It lacks crucial context about the sensitive nature of the output, security considerations, and how the parameters affect the output (e.g., phrase vs. private key).

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 documents all parameters with descriptions. The description adds no extra meaning beyond what the schema provides. 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 and resource: it outputs an identity's secret key. This distinguishes it from siblings like stellar_keys_public_key, though it doesn't explicitly name that sibling for differentiation. The purpose 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?

No guidance is provided on when to use this tool versus alternatives such as stellar_keys_public_key. The agent is left to infer usage context from the description alone.

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

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

With no annotations, the description carries the full behavioral burden. 'For all commands' hints at a persisted global scope, but the description never says the change is written to config, whether the named key must already exist, whether it is reversible, or what happens on an invalid name.

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

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

A single, front-loaded sentence with no filler. It is efficient, though its brevity is part of why the behavioral gaps exist.

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

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

For a simple two-parameter config setter with no annotations and no output schema, the description is minimally adequate but omits persistence semantics and the identity-vs-network ambiguity that an agent needs resolved before invoking 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 coverage is 100%, so the baseline is 3. The description's 'identity' framing conflicts with the schema text for 'name', which reads 'Set the default network name', so it adds context but does not resolve which value the parameter actually expects.

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+resource combination (set the default identity), which is clearer than a bare title. It does not, however, distinguish this tool from the sibling stellar_network_use, which performs the structurally identical 'set default network' operation, leaving ambiguity about which 'default' is being changed.

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, and no mention of alternatives such as stellar_keys_add, stellar_keys_list, or stellar_network_use. The agent must infer usage purely 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?

No annotations are provided, so the description must carry the full behavioral burden. It states a fetch operation, which implies read-only access, but does not explicitly disclose side-effect profile, required permissions, rate limits, or how network/rpcUrl configuration affects the call.

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 redundant or filler text. Every word contributes to the core purpose.

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

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

The schema is rich enough to document parameters, but there is no output schema and no annotations. The description does not explain what ledger information is returned or how network/rpcUrl selections affect behavior, leaving gaps for an agent invoking a multi-parameter fetch tool.

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

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

Schema description coverage is 100%, so the schema already documents all eight parameters, including sequence, limit, output, and network. The description adds no syntax or format details beyond the schema, 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?

Names a specific verb (fetch) and resource (ledger information) and states the lookup key (sequence number). It distinguishes itself implicitly from stellar_ledger_latest by requiring a sequence, but does not explicitly name the sibling alternative.

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

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

The phrase 'by sequence number' implies the tool is for known ledger numbers, but there is no explicit guidance on when to use it versus stellar_ledger_latest or other fetch tools. No when-not-to-use or alternatives 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 provided, so the description carries full behavioral burden. It never states whether this is a read-only operation, whether it hits the network, what happens if no network is configured, or what the return shape looks like. 'Information' is left undefined.

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 resource front-loaded. No waste, no ambiguity in 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 network query tool with no annotations, no output schema, and five parameters, the description is too thin. It doesn't disclose read-only nature, network prerequisites, or what 'information' is returned, leaving critical gaps for an agent.

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

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

Schema description coverage is 100%, so all five parameters including network selection, rpcUrl, and output format are already documented. The description adds nothing beyond the schema, making baseline 3 correct.

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+resource: 'Get the latest ledger sequence and information.' It distinguishes itself implicitly from stellar_ledger_fetch by emphasizing 'latest,' though it never names that sibling or clarifies the distinction.

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

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

No when-to-use guidance and no mention of alternatives. The only sibling-differentiating cue is the word 'latest,' which the agent must infer against stellar_ledger_fetch.

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 for a mutating tool, yet it discloses nothing: whether the config is persisted to disk, what happens on a duplicate name, whether credentials in rpcHeaders are stored, or what the result looks like. "Add" alone implies a write but gives no safety or side-effect context.

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

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

It is a single front-loaded sentence with zero padding, which is structurally clean. However, for a 5-parameter mutating tool, this brevity reads as under-specification rather than deliberate 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?

The tool has 5 parameters, a required triple, a nested object, no annotations, and no output schema, so the description is the only place to convey side effects and success/failure behavior. One bare sentence leaves the agent without enough to invoke it confidently beyond the schema.

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

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

Schema description coverage is 100%, so every parameter including the nested rpcHeaders object is documented in the schema itself. The description adds no extra semantics (format hints, defaults for configDir, header examples), 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 has a clear verb ("Add") and resource ("network configuration"), which is enough to separate it from stellar_network_remove, stellar_network_list, and stellar_network_use. It stops short of explicitly naming or contrasting those siblings, so it is clear but not fully differentiated.

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 stellar_network_use or stellar_network_settings, no statement of prerequisites (e.g., that name/rpcUrl/networkPassphrase are mandatory), and no note on whether the new network becomes the active one. 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, the description carries the full behavioral burden. It does not say whether the call mutates anything, what constitutes 'healthy', what happens on failure/timeout, or whether auth is required. 'Check' implies a read, but nothing confirms it.

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 padding. It is efficient, though its brevity comes at the cost of the missing detail 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 tool with six optional parameters, nested header objects, no annotations, and no output schema, the description is far too thin. It explains neither what the health check evaluates nor what its result conveys.

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 every parameter is already documented in the schema. The description adds no parameter meaning, which makes baseline 3 appropriate, though it could have clarified how rpcUrl/network/configDir interact with the 'configured RPC'.

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 ('check ... health of the RPC'), which is enough to identify the operation. However, it says 'the configured RPC' while the schema exposes rpcUrl/network/configDir overrides, so it is ambiguous which endpoint is actually checked, and it does not distinguish itself from siblings like stellar_doctor or stellar_network_info.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as stellar_doctor or stellar_network_info. The agent is left to infer the context 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?

No annotations are provided, so the description must carry the full behavioral burden. 'Get' weakly implies a read operation, but the description says nothing about what information is returned, authentication needs, rate limits, or side effects.

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

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

The description is a single front-loaded sentence with no wasted words. It is structurally efficient, though the sentence is so thin that its brevity partly reflects under-specification rather than ideal concision.

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

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

The tool has six optional parameters, a nested object, no annotations, and no output schema, so the description should explain more about what network information is returned and when to use this tool. As written, it is materially incomplete for the agent's decision-making.

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 six parameters are already documented in the input schema. The description adds no additional parameter meaning, 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 verb and resource ('Get detailed information about the network'), so the basic purpose is clear. However, 'detailed information' is vague and the description does not differentiate this tool from siblings such as stellar_network_health, stellar_network_settings, or stellar_network_list.

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, what alternatives exist, or what prerequisites or configuration choices (network, rpcUrl) matter. The agent receives no routing context despite many sibling network 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 supplied, so the description carries the full burden. It doesn't state that this is a read-only, non-mutating operation, doesn't describe what the output looks like (name list vs. table), and doesn't explain the effect of the `long` flag — all behavioral facts an agent would need.

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 — appropriately sized for a simple list tool. It is arguably too sparse rather than verbose, but there is no wasted prose to penalize.

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-required-parameter list tool with full schema coverage and no output schema, the minimum needed to invoke it is present. However, with no annotations, no output description, and a `long` flag whose effect is unexplained, the definition is only barely complete.

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

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

Schema description coverage is 100%, so both `long` and `configDir` are already documented in the schema and the baseline of 3 applies. The description adds no format, default, or interaction details beyond the schema text.

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?

"List configured networks" states a specific verb (List) and resource (networks) with the scoping qualifier "configured." It is clear on its own but does nothing to separate it from close siblings like stellar_network_info, stellar_network_settings, or stellar_network_health, which an agent could easily confuse it with.

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

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

The description gives no guidance on when to reach for this tool versus stellar_network_info/health/settings, nor does it state prerequisites (e.g. a config directory existing). With five network-related siblings, the absence of routing cues is a real gap.

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

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

With no annotations, the description carries the full burden yet only says 'Remove.' It does not disclose whether the removal is reversible, whether it affects the currently active network, required permissions, or side effects. This is a significant gap for a destructive 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?

A single, efficient sentence with no wasted words. It is front-loaded but arguably too terse to convey necessary 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 destructive operation with no annotations and no output schema, the description is insufficient. It omits critical information about side effects, reversibility, and interaction with the active network, leaving the agent under-informed.

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 both parameters thoroughly. The description adds no syntax, format, or behavioral detail beyond what the 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 (Remove) and resource (network configuration), which clearly distinguishes it from siblings like stellar_network_add, stellar_network_list, and stellar_network_use. It is clear but does not explicitly reference an alternative.

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

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

No guidance on when or why to use this tool versus alternatives such as stellar_network_use or stellar_network_settings. The agent must infer usage from the name and the sibling list 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 implies a read ('Fetch') but says nothing about whether it reads local config versus an RPC endpoint, what permissions are needed, or how the 'internal' non-upgradeable settings differ — the one behaviorally interesting hint (internal config) is left entirely to the parameter name.

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

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

A single short sentence with zero padding that is front-loaded and to the point. It is efficient, though its brevity borders on under-specification rather than tight 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 seven optional parameters, a nested object, no output schema, and no annotations, the description should do meaningful work. It does not explain what 'config settings' are returned, whether the result is local or remote, or how the output format selection affects the response, leaving significant gaps for an agent to call it correctly.

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

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

Schema description coverage is 100%, so all seven parameters are already documented in the schema, establishing a baseline of 3. The description adds no parameter meaning beyond what the schema provides — no clarification of network vs rpcUrl precedence or the internal flag's implications.

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 ('Fetch') and resource ('the network's config settings'), so the purpose is immediately clear. However, it does not distinguish this tool from nearby siblings such as stellar_network_info, stellar_network_list, or stellar_config_dir, leaving ambiguity about which config source it targets.

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 conditions, and no named alternative. With siblings like stellar_network_info and stellar_config_dir present, the agent is left to guess which one returns config settings versus network metadata or the config directory path.

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. 'Set' implies a write operation and 'for all commands' indicates scope, but the description does not explain persistence, required network validity, or side effects on existing configuration.

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 a simple configuration-setting tool.

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

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

Given the low complexity and full schema coverage, the core purpose is communicated. However, because annotations are absent and this is a mutating operation, the description should do more to explain behavioral context such as config persistence or error conditions.

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 are already documented in the input schema. The description adds no additional meaning beyond the schema, 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'), resource ('default network'), and scope ('for all commands'), making the tool's core action clear. However, it does not explicitly differentiate itself from sibling tools like stellar_network_add or stellar_network_settings, leaving the agent to infer the distinction.

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

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

The description offers no when-to-use guidance, no prerequisites, and no alternatives. An agent must infer that this tool is for changing the active network configuration rather than adding or listing networks.

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 says nothing about output format, whether plugins are user- or system-level, auth requirements, or side effects. 'List' implies read-only but that is not asserted.

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 three-word sentence. Front-loaded verb+resource with zero waste. Appropriately sized for a no-arg command.

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 no-param list command with no output schema, the description is minimally adequate. It would be stronger if it stated that output is a list of installed plugin names or distinguished from plugin_search.

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?

Zero parameters, so the baseline is 4. The description adds no parameter info because none exists, which is appropriate.

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

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

States a specific verb (List) and resource (installed plugins). Clear enough to distinguish from sibling stellar_plugin_search (which presumably searches a registry), though the description doesn't explicitly name that 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 when-to-use or when-not-to-use guidance. It does not mention stellar_plugin_search as the alternative for discovering uninstalled plugins. An agent must infer usage 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 exist, so the description carries the full burden. It hints that results are sourced from GitHub but says nothing about authentication, rate limits, whether anything is installed or modified, or the result format — all material for a tool an agent may invoke blindly.

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 no filler and the key concept (plugin search) front-loaded. It is under-specified rather than verbose, but as written every word 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?

The tool takes no inputs and has no output schema, so the description only needs to convey what invocation does. It covers that minimally, but leaves the agent unsure about network requirements, whether the search is remote, and what kind of results come back.

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 defines zero parameters, so there is no parameter semantics to document and no gap for the description to compensate for. 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 (Search) and resource (CLI plugins), and distinguishes itself from the sibling stellar_plugin_list by adding where results come from (GitHub). It is clear, but the mechanism ('using GitHub') is loose and could mean the API, raw repos, or a curated index.

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 when to prefer this over stellar_plugin_list or other plugin tools, and no prerequisites (network access, GitHub token). The only implicit signal is that it is a search rather than a listing.

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, and it does little beyond stating the operation. It doesn't say whether it writes/overwrites a local file, whether it requires a reachable history archive or network config, what permissions are needed, or what side effects occur — all critical for a tool that creates an output artifact.

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, which is efficient. It is arguably under-specified rather than padded, so it earns good marks for structure while leaving the completeness gap to 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?

For a mutation tool with 11 parameters, a nested object, one required field, no annotations, and no output schema, a single sentence is inadequate. The description omits default behavior, where the snapshot is written, and how network/archive selection interacts with the other 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 all 11 parameters including ledger, archiveUrl, out, and the required output enum are already documented in the schema. The description's mention of 'history archive' loosely maps to archiveUrl but adds no syntax, format, or default details beyond what the schema provides, 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 (Create), resource (ledger snapshot), and method (using a history archive), so an agent immediately knows what the tool produces and where it sources data. It does not name or differentiate against any alternative, but no sibling snapshot tool exists in the list, so differentiation is largely moot.

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

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

The description gives no guidance on when to use this versus other ledger/snapshot-related operations, no prerequisites, and no conditions. An agent must infer everything about fit from the one-line purpose statement.

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

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

No annotations are provided, so the description carries the full burden. It states that the source account is removed, which is a critical destructive behavior, but it omits irreversible consequences, required signatures, fee implications, and whether the operation can be undone. With no annotations, this is insufficient transparency.

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

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

The description is a single, front-loaded sentence that conveys the core action without any filler. Every word 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?

With no annotations and no output schema, the description should compensate by explaining destructive irreversibility, auth requirements, and submission behavior. It fails to do so, leaving significant gaps for a high-risk account merge operation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters clearly. The description adds no parameter-level meaning beyond what is in the schema, which is acceptable at baseline. It does not explain build_only behavior or fee units.

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: merge an account balance into another and remove the source. It distinguishes the operation from generic payment or send tools. However, it does not explicitly name sibling alternatives or clarify scope beyond the basic action.

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

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

No guidance is provided on when to use this tool versus alternatives like stellar_tx_send or stellar_tx_payment. There is no mention of prerequisites such as account existence, sequence number handling, or network selection.

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 reveals only that this is a mutation of trustline state; it does not say whether the transaction is signed and submitted by default, what permissions/signing keys are needed, or that limit=0 destroys the trustline. Those behaviors are only hinted at in schema parameter text, not the description.

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

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

A single front-loaded sentence with no wasted words. It is efficient, though its brevity comes at the cost of substance rather than being a model of compact completeness.

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

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

This is a state-mutating transaction tool with no annotations and no output schema, and the description omits the critical operational context an agent needs: that it submits to a network by default, signing requirements, and fee defaults. For a 6-parameter mutation tool, the definition is under-specified.

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

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

Schema description coverage is 100%, so all six parameters (including limit semantics and build_only) are already documented in the schema. The description adds no parameter-level meaning beyond what the schema provides, which is the baseline 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 set (create, update, delete) and a specific resource (trustline for an asset), which clearly separates it from siblings like stellar_tx_payment or stellar_tx_manage_data. It does not explicitly name or contrast with an alternative tool, so it stops short of a 5.

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

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

The description gives no when-to-use context, no prerequisites (e.g. that the source account must exist and be funded), and no mention of alternatives or when-not to use this versus stellar_tx_set_options. Usage is only weakly implied by the verb list.

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

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

With no annotations provided, the description carries the full behavioral burden, yet it only implies mutation. It does not state that this submits an irreversible on-chain transaction, that it spends real XLM on mainnet, or that build_only suppresses submission. These are significant omissions for a write tool with zero annotation coverage.

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, so nothing is wasted. It is arguably too terse, but the brevity itself is efficient rather than padded.

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 6-parameter mutating transaction tool with no annotations and no output schema, the description omits the essential context: submission behavior, funding requirements, network/irreversibility implications, and what the caller gets back. It is not complete enough for safe invocation.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters including network enum and build_only semantics. The description adds no parameter-level meaning beyond what the schema provides, which is the expected baseline 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?

States a specific compound verb ('create and fund') plus the resource ('new Stellar account'), so an agent can tell it apart from stellar_tx_payment or stellar_keys_fund at a glance. It does not, however, explicitly name any sibling or contrast its scope 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?

There is no when-to-use guidance, no prerequisites (e.g. the source account must already exist and hold sufficient XLM), and no routing to alternatives such as stellar_keys_fund for funding an existing account. The agent must infer the context 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?

No annotations are provided, so the description carries the full burden. It implies a read-only transformation ('decode to JSON') but says nothing about error behavior on invalid XDR, input encoding assumptions, or whether the operation is side-effect free. For a decode tool with zero annotation coverage this is a meaningful 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 no filler. The verb and resource lead the statement, and every word 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?

No output schema exists, and for a decode tool the resulting JSON structure is nontrivial yet unexplained. Combined with the lack of sibling differentiation against stellar_xdr_decode, the description is only minimally adequate 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 100%, so both parameters are already documented in the schema (tx_xdr as base64, output_format enum). The description's 'human-readable JSON' only loosely gestures at the output_format enum and adds no syntax or format detail beyond the schema 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?

States a specific verb (Decode), resource (transaction XDR), and output type (human-readable JSON), which is clear. However, it does not differentiate from the closely related sibling stellar_xdr_decode, leaving the agent to guess whether this is the transaction-specific variant or redundant.

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 context, no prerequisites (e.g., requiring valid base64 XDR), and no mention of alternatives such as stellar_xdr_decode or stellar_xdr_guess. The agent must infer usage purely 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?

No annotations are provided, so the description must disclose behavior. 'Fetch' implies a read-only network retrieval, which is useful, but the description stops short of permissions, error behavior, rate limits, or return characteristics.

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 wasted words, and the key action and resource are front-loaded. It is appropriately sized for a simple lookup 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?

For a simple two-parameter read tool with full schema coverage, the definition is minimally complete. It omits output shape and usage context, which is a gap because no output schema exists to explain return values.

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

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

Schema description coverage is 100%, so both parameters are already documented. The description only echoes 'by hash' for tx_hash and does not add meaning for the network parameter, 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 ('Fetch'), resource ('transaction'), and lookup key ('by hash'). It distinguishes network retrieval from local siblings like stellar_tx_decode or stellar_tx_hash, though it does not name them explicitly.

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

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

No when-to-use guidance, no alternatives, and no exclusions are provided. The phrase 'by hash' implies the required input but not the context for choosing this tool over sibling transaction tools.

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

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

With no annotations, the description carries the full burden, yet it discloses nothing beyond the basic action. It omits the critical behavioral fact that the resulting hash depends on the network passphrase, and says nothing about determinism, error behavior, or whether signed/unsigned envelopes are accepted.

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, which is appropriately sized for the stated action. It is efficient, though the brevity borders on under-specification for a cryptographic operation.

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

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

For a tool with no annotations and no output schema, the description is too thin: it never explains that network selection affects the hash, nor what the returned hash represents. The agent lacks enough context to call this correctly in a non-mainnet scenario.

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

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

Schema description coverage is 100%, so both tx_xdr (base64) and the network enum are fully documented in the schema, establishing the baseline of 3. The description adds no meaning beyond the schema, notably silent on the fact that the optional network parameter changes the hash output.

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 (calculate) and resource (hash of a transaction envelope), so the agent knows this is a hashing operation rather than the sibling decode/encode/simulate tools. It does not explicitly contrast itself with stellar_tx_decode or stellar_xdr_encode, so sibling differentiation is only implied by the verb.

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

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

There is no guidance on when to use this tool versus alternatives like stellar_tx_decode or stellar_tx_simulate, and no note on prerequisites such as whether the envelope must be signed or fully assembled. The agent must infer the usage context 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?

No annotations are provided, so the description carries the full behavioral burden, and it under-delivers. It does not disclose that this mutates on-chain state (delete is destructive/irreversible), that it signs and submits a transaction unless build_only is set, or what permissions/funds are required.

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

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

A single front-loaded sentence with no filler and no repetition. It is efficient, though it is arguably too thin for a 9-parameter mutation tool, which keeps it just short of the top score.

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

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

For a 6-required-parameter state-mutating tool with no annotations and no output schema, the description is inadequate. It omits the build-only vs. submit flow, network selection implications, signing requirements, and the destructive nature of the delete mode.

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% across all 9 parameters, so the schema already explains selling/buying/price/amount/network/offer_id/build_only. The description adds only the create/update/delete framing, which loosely maps to offer_id semantics but adds nothing beyond the schema. 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 specific verbs (create, update, delete) plus a concrete resource (buy offer on the DEX). The 'buy' qualifier implicitly separates it from the sibling stellar_tx_manage_sell_offer, but the description never names that alternative explicitly, so differentiation relies on the reader noticing the name.

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