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 disclose meaningful behavior: BASIC files are tokenized while BIN and data are copied unchanged, and the image is fixed at 35 tracks. However, it omits overwrite semantics, error behavior, and permission requirements, leaving notable gaps for a write tool.

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

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

Three compact sentences, each earning its place: the build action and format first, then path conventions, then file-kind behavior. Fully front-loaded with zero filler.

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

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

For a two-parameter write tool with no annotations and no output schema, the description covers the core action and file-kind handling but never says what is returned on success/failure or how existing files on the image are handled. It is adequate but leaves the agent guessing about outcomes.

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 only 50% (cocoName and kind lack descriptions), so the description must compensate. It does so by clarifying kind semantics (bas is tokenized, bin/data copied verbatim) and reinforcing the path conventions for hostPath and dskPath. This adds real meaning beyond the schema, though cocoName naming rules remain unaddressed.

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 precise verb and resource: 'Build a 35-track Disk BASIC image with ToolShed decb.' It names the exact output artifact (35-track Disk BASIC .dsk image) and the underlying tool, so an agent knows exactly what this produces. No sibling tool builds images, so no ambiguity exists despite the absence of explicit sibling references.

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 path conventions ('Prefer storage/disks for output and storage/host/bas|bin|data for inputs'), which implies intended usage, but never states when to use this tool versus alternatives or any preconditions. Usage is implied by the input/output layout rather than explicitly 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?

No annotations provided, so the description carries full burden. It implies a read-only list but doesn't state the safety profile, whether it requires a running emulator, or how the result is structured beyond field names.

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 waste. It efficiently communicates the resource and the returned fields.

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 zero-param list tool, the description is minimally adequate. However, with no annotations and no output schema, an agent lacks confirmation that this is a safe read operation and that no prerequisite state (such as a running session) is required.

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 correctly indicates no inputs are required and identifies what the output records contain.

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 (MAME image devices), with concrete examples (flop1, flop2). It doesn't reference any sibling tools, but the resource is distinct from mount/unmount/load state operations in the sibling 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 on when to use this tool versus alternatives. An agent cannot infer from the description alone whether this is a discovery step before coco_mount_flop or something else.

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

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

With no annotations, the description carries the full behavioral burden and does disclose two substantive traits: an immediate synchronous failure when no matching file exists, and asynchronous execution with a 'scheduled' result otherwise. It does not say whether loading overwrites the current machine state or what permissions/preconditions apply, so a small gap remains.

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

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

Two tight sentences, front-loaded with the action, followed by the failure and async-result behavior. Every clause earns its place with no filler.

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

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

For a one-parameter, annotation-free tool with no output schema, the description covers the essential action, failure mode, and result semantics. It stops short of stating what 'scheduled' means for the caller or whether the load is destructive to current state, which are the only meaningful omissions.

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

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

There is one parameter and schema description coverage is 100%, so the schema already defines 'name' as the state name under the state directory. The description only echoes that resolution context ('no matching file exists in the state directory') without adding naming conventions, extensions, or path semantics, so the baseline 3 applies.

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

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

The description gives a specific verb and resource ('Schedule a MAME state load') and adds scope detail about when it fails and how the result is delivered. It is clearly distinguishable from its obvious counterpart coco_save_state by the load/save opposition, though it never names 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?

Usage is only implied: the tool restores a named state, so the context is a running machine that has previously saved one. There is no explicit when-to-use, no prerequisites, and no comparison against adjacent tools like coco_soft_reset, coco_snapshot, or coco_start, which could also move the machine into a prior condition.

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 disclose two real traits: relative paths are resolved from the MCP root, and valid drives come from manager.machine.images. It does not say what happens if a disk is already mounted in that drive, whether the mount can fail, or what an error looks like.

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

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

Three short sentences with the core action front-loaded and no filler. The trailing sentence about manager.machine.images is slightly cryptic and would benefit from plainer wording.

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 mutation tool with no annotations and no output schema, the description covers the essentials but omits mount-state semantics (overwrite/replace behavior, failure modes). Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema, establishing a baseline of 3. The mention that drives come from manager.machine.images adds a small hint about the drive enum's origin but no syntax or format detail beyond the schema.

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

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

States a specific verb (mount) and resource (disk image on flop1/flop2), which cleanly separates it from siblings like coco_unmount_flop and coco_build_disk. It does not explicitly name an alternative, but the operation 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?

Gives useful path guidance ('Prefer paths like storage/disks/game.dsk') but never says when to use this versus coco_build_disk (create a disk first?) or whether an unmount is needed before remounting. Usage is implied rather than 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 behavioral burden. It does disclose a genuinely important trait — reads go through the MMU window, and $0400 maps to the text screen only in CoCo 1/2-compatible mode. However it says nothing about return encoding, behavior on unmapped/out-of-range addresses, or whether reads have 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?

Two tight sentences, with the crucial scope constraint ('not physical RAM') front-loaded. No filler. The $0400 sentence is narrow but earns its place as a concrete mapping example.

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

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

For a two-parameter read tool with no output schema, the description covers the address space but omits how bytes are returned (hex string vs. array) and error behavior for invalid addresses/lengths. Adequate but leaves a real gap for a tool whose whole job is producing a value.

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 address and length are already documented with formats and ranges. The description reinforces the address semantics (MMU window) and adds the $0400 example, which is useful domain context but largely overlaps 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?

Clear verb+resource (read bytes) with an explicit scope qualifier: the current 64K MMU window rather than physical RAM. This is enough to separate it from coco_write_memory by direction, though no sibling is named. Purpose is unambiguous without opening the 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?

Usage is implied by the addressing semantics rather than stated. The description does not say when to prefer this over, say, coco_snapshot or coco_status for inspecting machine state, nor does it set preconditions (e.g., machine must be 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?

With no annotations, the description carries the full behavioral burden, and it does disclose two useful traits: the save is asynchronous and 'fileFound' reports whether the file appeared. It says nothing about permissions, failure modes, or whether an existing state with the same name is overwritten, which matters for a write 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?

Two short sentences, zero waste, with the action and its asynchronous nature front-loaded. Nothing repeats the schema or the tool name.

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

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

For a one-parameter write tool, the description covers the key gap an agent would hit: the operation is async and completion is signalled via 'fileFound'. It leaves overwrite/collision behavior and error conditions unaddressed, but there is no output schema to lean on for the return signal, and it partially compensates by naming 'fileFound'.

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

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

Schema coverage is 100% for the single 'name' parameter, so the schema already explains that it is the state name under the state directory. The description adds no format, naming-convention, or collision semantics beyond that, so baseline 3 applies.

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

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

States a specific verb ('Schedule a MAME save') and resource ('state directory'), which cleanly separates it from coco_load_state and the other state/snapshot siblings. It stops short of explicitly naming a sibling or a condition that picks it over 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 when-to-use or when-not guidance is given; the agent must infer that this is the counterpart to coco_load_state. The asynchronous note is contextual, not a usage rule.

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 usefully disclose the fallback behavior (returning the newest PNG in the snapshot directory) and implies a non-destructive read, but it omits whether the emulator must be started first, whether current.png is overwritten, and what happens if no snapshot exists at all.

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

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

Two tight sentences with zero filler; the primary behavior (capture and return) is front-loaded and the fallback is relegated to a second sentence where it belongs.

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 the description correctly states the return value is the PNG. For a zero-parameter tool this is nearly complete, with only the precondition (emulator running) and no-snapshot-exists case left unspecified.

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

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

The tool takes zero parameters, so the schema carries nothing to document and the baseline for a parameterless tool is 4. There is no parameter syntax an agent could get wrong.

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 (Capture) and resource (the CoCo screen) plus the exact output artifact (snapshots/current.png and the returned PNG). No sibling tool in the list performs screen capture, so it is unambiguously distinguishable.

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 by the purpose — an agent calls it when it needs to see the current emulator screen — but there is no explicit when-to-use statement, no prerequisites (e.g., emulator must be running), and no named alternative or exclusion.

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

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

With no annotations, the description carries the full burden. It usefully discloses that this is a non-destructive soft reset rather than a MAME hard reset, but says nothing about whether emulated state is preserved, whether the emulator must already be running, or what happens to a mounted floppy/loaded state.

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

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

Two short sentences, zero waste, with the core action front-loaded and the caveat immediately after. Nothing is 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 parameterless reset tool with no annotations or output schema, the description covers the essential action and its non-destructive nature, but omits prerequisites (emulator running state) and the effect on other session state that an agent would want 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?

The tool takes zero parameters, so the schema imposes no semantic burden and the baseline of 4 applies. The description correctly implies no arguments are needed.

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

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

States a specific verb and resource ('soft-reset the emulated CoCo'), which an agent can act on directly. It distinguishes soft from hard reset but does not differentiate itself from the other lifecycle siblings (coco_start, coco_stop, coco_load_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?

No when-to-use guidance is given. The clause 'does not hard-reset MAME' is a scope boundary, not a usage condition, and it never says when a soft reset is preferable to coco_stop/coco_start or coco_load_state.

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

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

No annotations, so description carries the full burden. It does disclose key behavior: it 'waits until the Lua bridge answers ping,' implying it blocks and confirms readiness. However, it's silent on failure modes (timeout, port conflicts), whether it's idempotent, and what state it leaves behind.

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 sentence, front-loaded with the action and target, then the readiness condition. No waste.

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

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

For a zero-parameter, no-annotation startup tool, the description covers the core action and readiness wait. But it omits critical context: what happens if spawning fails, whether it must be called before sibling tools, and whether the bridge readiness is a precondition for subsequent commands.

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 baseline 4 per rubric. No parameter semantics to describe, and the description correctly does not invent any.

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

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

Clear verb+resource+environment: 'Spawn local official MAME coco3 with the disk controller.' Specific enough to know exactly what it launches. No explicit sibling differentiation (e.g., vs. coco_stop or coco_soft_reset), but the action is unambiguous.

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

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

No when-to-use or when-not-to-use guidance. The description implies you call this to start the emulator but doesn't state prerequisites (e.g., must be called before other coco_* tools) or whether it's a one-time setup versus repeatable.

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 helpfully enumerates the three things it reports (MAME process, bridge, flop1 mount), but says nothing about whether the call is side-effect free, how it behaves if the bridge is unreachable, or what the return shape looks like.

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 that front-loads the verb and enumerates the reported items with no filler. Nothing is wasted.

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

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

For a parameterless status probe with no output schema and no annotations, the description covers the substantive questions (is MAME up, is the bridge alive, what is mounted). The main gap is not hinting at the response format, but the enumerated items largely serve that role.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. No parameter confusion is possible.

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 (Report) and names exactly what is reported: MAME running state, bridge responsiveness, and the mounted flop1 image. This is clearly distinct from action siblings like coco_start/coco_stop and listing tools like coco_list_images, though it never names a sibling directly.

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 can infer this is a pre-flight health check before other emulator operations, but there is no explicit when-to-use guidance, no mention of alternatives, and no stated exclusions.

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

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

With no annotations, the description carries the full burden. It usefully discloses that the whole process tree is terminated and that the bridge listener is closed (so subsequent commands will fail), but says nothing about whether unsaved state is lost, whether the operation is reversible, or what happens if no process is running.

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

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

A single front-loaded sentence with no filler; the action and both affected resources are stated immediately with zero redundancy.

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

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

For a zero-argument teardown with no output schema and no annotations, the description covers what is stopped and the side effect on the bridge listener. The main gap is not warning that in-emulator state is discarded, which matters for an agent deciding whether to save first.

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

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

The tool takes zero parameters, so the schema provides nothing to interpret and the baseline of 4 applies. There is no parameter meaning the description could add.

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

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

States a specific verb (stop) and specific resources (the MAME process tree and the bridge listener), so an agent knows this is a full teardown rather than a reset. It implicitly distinguishes itself from siblings like coco_soft_reset and coco_start, though it never names an alternative explicitly.

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

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

The use case (shutting down the emulator) is implied by the verb and resource, but there is no explicit guidance on when to choose this over coco_soft_reset or coco_save_state first. No prerequisites, ordering, or exclusions are 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 and does add real value beyond the schema: it discloses that the call waits until the post queue is empty and nothing is posting, i.e. it is blocking. However, it omits other important traits such as error behavior, what happens if the emulator is not running, and whether the input is delivered asynchronously.

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 before the behavioral clauses, with no filler. The second half is slightly dense ('appends {ENTER} when it is not already present, then waits until the queue is empty and not posting') but every clause earns its place.

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

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

For a two-parameter tool with no annotations and no output schema, the description covers the core mechanics and the blocking behavior adequately. It is still thin on state requirements and failure modes, which an agent would need before relying on it in a scripted sequence.

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, giving a baseline of 3. The description's restatement of the pressEnter default is redundant with the schema, and it adds no extra meaning for 'text' beyond the vague 'natural-keyboard string' phrasing.

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: 'Post one natural-keyboard string.' An agent immediately understands this injects keyboard input into the emulator, which is clearly distinct from the memory/disk/state siblings. It stops short of explicitly naming which sibling to prefer, but the purpose itself is unambiguous.

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

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

There is no statement of when to use this tool versus alternatives, nor any prerequisite (e.g., that the machine must be started/running, or that this is the way to drive interactive programs). The queue-draining clause hints that calls are safely sequenced, but that is behavioral detail rather than usage guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say what happens if no image is mounted (error vs no-op), whether the operation is reversible, or whether it requires an active session, which are meaningful gaps for a state-mutating tool.

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

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

A single front-loaded sentence with no filler. It is efficient, though extremely terse and could carry one more clause of useful context without bloat.

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

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

For a one-parameter, no-output-schema tool this is minimally adequate, but with no annotations and no mention of preconditions or failure behavior, an agent lacks the context to know when the call is valid.

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 'drive' parameter already documents its enum values and flop1 default. The description merely restates the drive options, adding no semantics 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?

States a specific verb ('Unload') and resource ('disk image') scoped to the two floppy drives, which cleanly distinguishes it from the sibling coco_mount_flop. It is clear without needing to open the schema, though it does not explicitly name the inverse 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?

The description implies the operation (unload a mounted image) but gives no explicit when-to-use guidance, no prerequisites such as needing the emulator running or an image mounted, and no reference to alternatives. Usage is inferable but 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. It discloses one genuinely important behavioral trait — that writes land in the MMU-mapped window rather than physical RAM — but says nothing about what happens on unmapped addresses, whether the write can corrupt emulator state, or any error behavior.

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

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

A single front-loaded sentence with zero filler; the scope constraint is stated immediately after the action rather than buried.

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

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

For a 2-parameter mutation tool with no annotations and no output schema, the description covers the essential semantic (MMU vs physical RAM) but omits failure modes and any note on how the hex data string maps to addresses. Adequate but with clear gaps.

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

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

Schema description coverage is 100% (both parameters documented, including 'space-separated hex bytes' and 'hex address in the current 64K MMU window'), so the schema already does the heavy lifting. The description adds no syntax or format detail beyond that, 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 and resource ('write bytes') and adds a precise scope caveat ('current 64K MMU window, not physical RAM') that clearly separates it from physical-memory writes. It doesn't explicitly name the counterpart sibling coco_read_memory, but the write/read pairing is unambiguous.

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

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

The description offers no when-to-use guidance, no prerequisites, and no exclusions. An agent must infer from the name alone that this is the mutation counterpart to coco_read_memory and that it targets emulated MMU space rather than host state.

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