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

No annotations, so the description carries the full burden. 'Atomic' usefully implies all-or-nothing semantics, but it says nothing about what happens on revision conflict, whether changes are persisted or reversible, whether a session must be opened first, or how request_id/idempotency behaves. The pointer to 'protocol v1' references a document the agent cannot see.

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 tight sentence with no filler, but the compression is achieved by delegating the substance to an unavailable external spec rather than by being information-dense. Short is not the same as efficient here.

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 6-parameter mutation tool with no annotations, no output schema, and 0% schema coverage needs substantial description. Instead the description punts on the single hardest part — the operations payload format — to a 'protocol v1' the agent has no access to, so the definition is not callable without outside knowledge.

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

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

Schema description coverage is 0% across 6 parameters, including an opaque objects array and three concurrency/idempotency fields (expected_revision, expected_context, request_id). The description only obliquely gestures at 'specified revision' and defers the rest to an external protocol, leaving the agent unable to construct operations correctly.

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 verb and effect ('executes an atomic batch at the specified revision'), which is more than a restatement of the name. But it never says what an 'operation' is or what resource is being modified, so the agent cannot distinguish it from save_sprite or undo/redo beyond guessing. Purpose is inferable but 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?

There is no statement of when to use this tool versus undo, redo, or save_sprite, and no preconditions. The agent gets no routing signal at all.

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 discloses that the created document is unsaved (not persisted), and omits everything else: whether a session must exist first, whether the document appears in list_documents, reversibility/undo behavior, and what the call returns.

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, so there is no padding, but the brevity here reflects under-specification rather than economy — the sentence is too thin to be useful for a 4-parameter creation 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 annotations, no output schema, no parameter documentation, and 3 required parameters including an opaque session_id, the description leaves an agent unable to call this correctly without guessing. It is far from complete 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 0% and none of the four parameters (width, height, session_id, request_id) are explained in the description. It does not even clarify that width/height are in pixels or what session_id identifies; the description adds nothing beyond the bare schema titles.

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 ('创建...RGB 文档' — create an RGB document), and 'unsaved' hints at how it differs from save_sprite. However, it never uses the word 'sprite' in a way that ties to the tool name, and it says nothing about dimensions, session scoping, or how the result relates to list_documents.

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 call this versus list_documents, save_sprite, or get_document_info. The 'unsaved' qualifier weakly implies a later save is needed, but no exclusion, precondition, or alternative is 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 signals a non-mutating read ('读取') and emphasizes 'real-time', implying live state and no caching, which is useful. It does not state permission requirements, whether the call is cheap/safe to repeat, or how failures surface.

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 enumerating the four returned fields, front-loaded with the most important part (real-time session). Nothing wasted, nothing repeated from the schema.

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

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

For a zero-parameter read tool with no output schema, enumerating the returned fields is exactly the right compensation, since there is no structured return definition. Only the read-only/non-destructive nature and auth expectations are unstated.

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 parameter semantics is a baseline 4. The description correctly adds no parameter discussion and instead spends its words on the returned content.

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 resource and enumerates its parts: real-time session, software version, local endpoint, and enabled capabilities. An agent can tell this is a status/diagnostics read, distinct from the document and sprite siblings. It never uses an explicit verb like 'returns' or 'reads' in a named form, but the resource is unmistakable.

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 call this versus other tools, no prerequisites, and no mention of when it is unnecessary. The agent must infer that it is a diagnostic check, likely at startup or before other operations.

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

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

With no annotations, the description must carry the full burden. It discloses two useful traits: the document is in memory, and identifiers are session-scoped and therefore invalid across sessions. It says nothing about what happens when the document is missing or the session has expired, nor does it state explicitly that the operation is read-only beyond the verb 读取.

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?

There is a single short sentence with no padding, so it is concise. However, it is too terse for the information the description needs to convey, and it is not front-loaded around any usage or parameter guidance.

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 tool has two required parameters, no schema descriptions, no annotations, and no output schema, so the description should explain much more. It covers basic scope and the session lifetime but omits return content, error conditions, and parameter meaning.

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

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

Schema description coverage is 0%, so the description must compensate, but it does so only weakly. It hints that the identifier (标识) is session-bound, which touches document_id and session_id, but it does not clarify the format of either parameter or the difference between the two required parameters.

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

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

The description names a read operation on an 'in-memory document' (读取显式内存文档), which partially clarifies the resource. However, the tool name promises 'document info' while the description says only 'read', leaving the actual output purpose (that is, metadata versus content) ambiguous. It also does not distinguish this tool from the sibling tool list_documents.

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 only usage context is the constraint that the identifier is valid only within the current session (标识仅在当前会话有效), which implies a session-scoped workflow. It does not say when to use this tool instead of list_documents or get_preview, and it does not name any prerequisites or exclusions.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the return format (PNG image plus metadata) and nearest-neighbor scaling, but omits read-only/side-effect safety, permission requirements, revision-mismatch behavior, and session/document constraints.

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

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

The description is one compact sentence with no filler and front-loads the return action. The trailing scaling detail is useful but makes the sentence slightly terse rather than fully structured.

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 are no annotations, no output schema, and six parameters with zero schema descriptions. The description gives the core purpose and output format, but it is not complete enough for correct invocation of a multi-parameter read tool.

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

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

Schema description coverage is 0% for all six parameters. The description only partially covers revision, frame, and scaling concepts, while session_id, document_id, and region are left undocumented.

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 returns a PNG image and metadata for a specified revision/frame. This is distinguishable from siblings such as list_documents or get_document_info, though it does not 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?

It only says the tool directly returns a preview image for a revision/frame; there is no explicit when-to-use, when-not-to-use, or alternative selection guidance among sibling tools. The agent must 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?

No annotations are provided, so the description carries the full burden, yet it only hints that documents are in-memory (non-persisted). It says nothing about what a session is, whether documents persist, or what the result contains.

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 a front-loaded verb. It is efficiently sized, though the terseness contributes to the under-specification 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?

With no annotations and no output schema, the description should explain the return shape (document ids vs. metadata) and session semantics, but it does neither. An agent could not confidently call this tool correctly from the description alone.

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

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

Schema description coverage is 0% for the single required parameter session_id, and the description never explains what a session id is or how to obtain one. The term '显式编辑器会话' (explicit editor session) is introduced but never defined, so the one parameter remains opaque.

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 (list documents) scoped to an editor session, which distinguishes it from get_document_info. However, the qualifiers 'in-memory' and 'explicit session' are unexplained, leaving the exact scope somewhat fuzzy.

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 instead of get_document_info or other siblings, and no prerequisites or exclusions. 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?

With no annotations, the description carries the full behavioral burden and mostly fails: it hints at an optimistic-concurrency check (the revision must match) but never says what happens on mismatch, whether the redo is itself reversible, what state is mutated, or what permissions/session state are needed. The one disclosed trait — revision must match — is the only real behavioral value present.

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 short sentence with no filler, which is structurally fine, but the brevity is under-specification rather than economy — the one clause present is cryptic ('显式文档') rather than front-loaded with actionable meaning.

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

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

For a mutation tool with no annotations, no output schema, and 0% parameter documentation, the description does far too little: it omits error behavior on revision mismatch, the relationship to undo, and the meaning of the required identifiers. An agent could call it, but would be guessing about failure modes and side effects.

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

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

Schema description coverage is 0% across 4 parameters, so the description must compensate and does not. '修订' loosely maps to expected_revision, but session_id, document_id, and request_id (including whether request_id provides idempotency) are left entirely unexplained in both schema and description.

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

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

The verb 'redo' (重做) is specific and pairs implicitly with the sibling 'undo', but the object '显式文档' (explicit document) is an unusual phrasing that leaves it unclear whether the tool redoes an operation, a document state, or an edit session. An agent can guess it re-applies something that was undone, but the resource is not stated crisply enough to distinguish it confidently from apply_operations.

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

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

There is no statement of when to use this versus 'undo' or 'apply_operations', which are the obvious alternatives. The clause '要求匹配修订' implies a precondition on expected_revision, but no explicit when/when-not guidance or exclusion is 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?

With no annotations, the description carries the full burden: it does not disclose overwrite semantics, the optimistic-concurrency role of expected_revision, whether unsaved changes are flushed, or what errors occur on revision mismatch. Only the path requirement for unnamed documents is surfaced.

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 path condition is placed immediately after the main action. Brevity here borders on under-specification rather than padding.

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 mutation tool with six parameters, no annotations and no output schema needs substantially more disclosure than this. Key behaviors an agent must know to call it safely — overwrite risk, revision-conflict handling, return value — are absent.

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

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

Schema description coverage is 0% across 6 parameters, and the description only illuminates one of them (path for unnamed documents). overwrite, expected_revision, request_id, session_id and document_id remain entirely undocumented, so the description fails to compensate for the coverage gap.

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

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

States a specific verb and resource ("显式保存文档" – explicitly save the document), and the qualifier distinguishes it from implicit/auto-saving. It is clear enough to separate from create_sprite, though the object is called a 'document' here while the tool is save_sprite.

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 one conditional rule (unnamed documents must specify a path), which is useful, but says nothing about when to prefer this over apply_operations or whether saving is needed after edits. 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 supplied, so the description must carry the full behavioral burden. It implies a mutation (something is reverted) and a concurrency guard ('requires matching revision'), but says nothing about what happens on revision mismatch, whether the undo is itself undoable, what gets restored, or what the result looks like — all critical for a destructive-ish 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?

One short sentence, front-loaded with the verb, so there is no waste — but the brevity is a byproduct of under-specification rather than disciplined density.

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

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

For a mutation tool with zero annotation coverage, no output schema, and 0% schema descriptions, the description leaves most of the operational picture (prerequisites, failure modes, idempotency) unaddressed. It gestures at revision matching but is far from sufficient.

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

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

Schema coverage is 0% with 4 parameters (request_id, session_id, document_id, expected_revision) all undocumented. The phrase 'requires matching revision' hints at the expected_revision parameter's conflict-check role, but session_id, document_id, and request_id (idempotency?) get no 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?

The description contains an undo verb plus 'document', but '撤销显式文档' is ambiguous phrasing that doesn't clearly state it reverts the last explicit edit on a document, nor does it distinguish the tool from the sibling 'redo' or 'apply_operations'. An agent would need to guess whether this undoes an edit, a session, or a transaction.

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 indication of when to use this tool versus 'redo' or 'apply_operations', no precondition beyond the vague 'matching revision', and no exclusion or alternative named. The agent is left to infer the whole call policy.

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