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

With no annotations provided, the description must carry the full behavioral disclosure burden. It states the basic side effect—adding an annotation to the session timeline—but does not disclose whether annotations are persisted, whether they are immediately visible to 'get_annotations', whether adding is idempotent, or what happens on error. 'Add' implies mutation, but the consequences are left unspecified.

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 wastes no words. It names the action, the object, and the target while remaining easy to parse quickly.

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

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

The tool has no output schema and no annotations, and the description does not explain the expected return value, side effects, or how this fits into the broader investigation workflow. An agent is not told whether the annotation concept is a crucial part of root-cause tracking or a lightweight note. Given the tool's moderate complexity (5 parameters, 1 enum), the description is minimally functional but incomplete.

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 80%, so most parameters already carry useful meaning in the input schema. The description adds no insight into the semantic roles of 'label', 'comment', 'category', or 'nodeId' beyond the existing schema descriptions, but it also does not need to compensate heavily. The missing parameter is the 'category' enum, which has no schema description; the description does not clarify when each category should be chosen.

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

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

The description uses a specific verb ('Add') with a clear object ('investigative annotation or hypothesis') and a destination ('session timeline'), which makes the core purpose immediately understandable. It does not explicitly contrast itself with the sibling 'get_annotations' tool, but the action is distinct enough that confusion is unlikely.

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 indication of when to use this tool versus alternatives. It does not mention that reads from the same timeline should go through 'get_annotations', nor does it state any prerequisites such as needing an existing session. An agent must infer entirely from the tool name that this is the write counterpart.

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 itself carries the burden of explaining behavior. It adds some useful behavioral context beyond the tool name: the screenshot is bound to the element's exact geometry and accounts for the device pixel ratio. However, it does not disclose whether the screenshot is returned directly, saved, or how it compares to a full-page capture.

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 sentence that front-loads the core action. There is no wasted text, though the phrasing 'target element exact geometry' is slightly awkward and could be more polished. Overall it is concise and scannable.

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 three optional targeting parameters, no output schema, and no annotations, the description is too thin for reliable invocation. It does not state how to obtain or choose between nodeId, selector, and selectedElementRef, nor what the tool returns. An agent would likely need to consult sibling tools or documentation to use it correctly.

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

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

Schema description coverage is 100%, so all three parameters have individual descriptions. The tool description adds no meaning beyond the schema, but it also does not need to, since the schema already documents nodeId, selector, and selectedElementRef. The main gap is that the description does not explain how the three targeting parameters relate or which one to prefer.

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

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

The description uses a specific verb and resource: 'Capture an element-specific screenshot'. The phrase 'element-specific' helps distinguish it from sibling tools like capture_page_screenshot, though it does not explicitly name that alternative. The inclusion of 'bounded to the target element exact geometry and device pixel ratio' further clarifies scope.

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 is given on when to use this tool versus alternatives such as capture_page_screenshot or get_screenshots. The reader can infer utility from the purpose, but there is no stated exclusion, alternative, or prerequisite. This lack of routing guidance leaves the agent to guess among the many screenshot-related sibling 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 burden of behavioral disclosure. It adds usefule behavioral facts: the capture is of the visible viewport and will include temporal, scroll, and viewport metadata. However, it does not state the obvious read-only/non-destructive character or describe what the result 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 sentence with the action front-loaded, the scope stated clearly ('visible browser page viewport'), and the metadata detail appended at the end. No wasted words or repetition.

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

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

For a low-complexity tool with one optional parameter and no output schema, this description gives enough to select and invoke it. The only minor gap is that the 'metadata' content is not elaborated, but knowing the exact metadata structure is not needed to call 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?

The input schema has 100% parameter documentation coverage for the single optional 'format' parameter, so the schema already explains the enum and default. The description adds no extra meaning about the parameter, but does not need to because the schema is complete.

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

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

The description opens with the specific verb and resource: 'Capture a screenshot of the visible browser page viewport.' It clearly scopes the operation to the visible viewport as opposed to the full page, and no sibling tool appears to offer screenshot capture, so it is easily distinguished.

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 'visible browser page viewport' establishes when this tool applies and implies it is not for full-page or off-screen captures. It does not name alternatives or exclusions, but no sibling screenshot tool exists, so explicit routing is less critical.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Delete' without mentioning whether deletion is permanent, whether it affects associated data, or what happens if the sessionId does not exist.

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 concise sentence with no wasted words. It is front-loaded with the verb and resource, though it is so brief that it misses important 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?

The tool is simple with one well-documented parameter, so the description is minimally adequate for invocation. However, as a destructive operation with no annotations or output schema, it would be more complete if it noted irreversibility 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?

The schema already provides 100% coverage of the only parameter, sessionId, with a clear description. The tool description adds no additional parameter semantics, but none are needed 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?

The description states a specific verb ('Delete') and a clear resource ('a recording session from storage'), making the tool's purpose immediately obvious. It also distinguishes itself from sibling read/export/import tools by explicitly naming deletion as the 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?

The description gives no guidance on when to use this tool versus alternatives such as export_session or get_session. It also does not mention prerequisites, consequences, or scenarios where deletion should be avoided.

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 behavioral burden. It discloses that the tool returns structured additions, removals, moves, attribute, style, and text changes, which is useful. However, it does not mention constraints such as requiring a complete endpoint pair, handling of mixed timestamp/event inputs, or whether the operation is read-only.

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, dense sentence that leads with the verb and object, states the two valid endpoint modes, and lists the output categories. There is 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 tool with no output schema and no annotations, the description gives a good high-level summary but omits the endpoint-pairing constraint and what happens if only one timestamp/event is provided. It is adequate yet leaves a moderate ambiguity in the calling contract.

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 baseline is 3. The description adds the concept of 'T1/T2' and 'E1/E2' as alternative endpoint pairs, but it does not add format, precedence, or pairing rules beyond what the schema already states.

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, 'Compare two DOM states', identifies the endpoint pair options (timestamps or events), and enumerates the exact change categories returned. This makes the tool's purpose clear and distinguishes it from single-snapshot siblings like get_dom_state or specialized change tools like find_disappearing_elements.

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 usage for obtaining a structured diff between two DOM states, but it does not state when to prefer diff_dom over related siblings, nor does it give any exclusions or prerequisites. There is no explicit 'when to use / 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?

With no annotations, the description carries the behavioral disclosure burden. It does reveal the primary output trait (a self-contained JSON bundle) but does not explicitly state that the operation is non-destructive or describe what 'complete' includes (events, screenshots, DOM states, etc.).

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 efficiently front-loads the action and object, and every word adds meaning. No filler or redundancy.

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

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

For a one-parameter tool with no output schema and no annotations, the description plus schema are enough for a basic call: the agent knows what to pass and what to expect back. However, it leaves the relationship to get_session and import_session implicit, so a bit more context would be ideal.

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

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

The schema covers the only parameter, sessionId, 100% with a clear description ('Unique identifier of the recording session'). The tool description adds no parameter-level nuance, 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?

The description states a specific verb ('Export'), a defined resource ('complete recording session'), and the output form ('portable, self-contained JSON bundle'). The phrase 'complete' and 'portable, self-contained' distinguishes it from a simple retrieval like get_session and clearly marks it as the counterpart of import_session.

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 use case (portability, backup, transfer) but does not explicitly state when to choose this tool over siblings such as get_session or import_session. No exclusions or alternative-selection guidance is 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It does disclose that the tool identifies both removed and hidden elements, which is useful, but it does not explain side effects, performance implications, output format, or limits of the scan. For a tool that 'automatically scans the session,' the description gives little about what the agent should expect after invocation.

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 sentence and is easy to parse, with the main action front-loaded. It is not bloated, though 'Automatically' adds little value since scanning inherently implies automation. Overall it is concise but leaves out meaningful details rather than being verbose.

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 there is no output schema and no annotations, the description should compensate by explaining what is returned, how results are structured, and when results are reliable. It does none of this. The sibling list shows related diagnostic tools, but the description does not position this tool within that workflow, leaving a significant completeness gap.

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 parameters are already documented well, including the default for maxLifespanMs. The description does not add semantic meaning beyond the schema, such as how lifespan interacts with 'temporary' elements or what sessionId must refer to. This keeps it at the baseline 3 for schema-heavy parameter 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 clearly states the tool scans a session and identifies elements that were temporary and then removed or hidden. The verb 'identify' and resource 'elements that existed temporarily...' make the core purpose understandable. However, it does not explicitly differentiate itself from sibling tools like trace_element or why_did_element_disappear, though 'all elements' implies a broad sweep rather than a single-element lookup.

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 about when to choose this tool over siblings such as why_did_element_disappear, trace_element, or diff_dom. The description implies a session-wide scan, but there is no explicit statement of use cases, exclusions, or alternatives. An agent would be left guessing whether this is the right tool for a post-hoc investigation versus live observation.

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 burden of behavioral disclosure. It indicates a read-only retrieval operation and specifies that it returns all human and AI annotations, but it does not mention pagination, ordering, authentication, or return format, so behavioral detail is only partially covered.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to the functional meaning: the verb, the annotation categories, and the session scope.

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

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

For a simple one-parameter getter with no output schema, the description covers the essential what and scope. It lacks an explicit pointer to sibling tools or return shape, but the operation is straightforward and the core invocation detail is present.

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

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

The schema already documents sessionId with 100% coverage, so the baseline is 3. The description's 'for a session' expression simply restates the parameter's role and adds no format, syntax, or edge-case 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?

The description uses the specific verb 'Retrieve' with the resource 'annotations' and clarifies scope ('all human and AI' and 'for a session'). It clearly differentiates the tool from session and event tools by its annotation-focused resource, though it does not explicitly name any sibling.

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

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

There is no guidance on when to use get_annotations versus siblings such as annotate_session or get_events. It does not mention prerequisites, alternatives, or the specific context in which this tool is preferred, leaving selection to inference.

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

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

In the absence of annotations, the phrase 'Query recorded ...' communicates a read-only operation over historical data, which is meaningful behavioral context, and 'with stack traces' describes what is included. It does not, however, state side-effect-free behavior explicitly or describe boundaries such as lack of live capture, result limits, or missing-session 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 no filler; every phrase ('recorded', 'console messages', 'runtime errors', 'unhandled promise rejections', 'with stack traces') adds distinguishing meaning. It is appropriately concise for a diagnostic query 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 four-parameter query with full schema documentation, the description is nearly complete: it names the resource, indicates historical/recorded data, and notes stack traces. Since there is no output schema, it could be stronger by mentioning ordering, pagination, or return shape, but the core invocation context is covered.

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 four parameters; the description adds no new parameter-level meaning. It gives useful output context (console messages/errors/rejections) but does not explain timestamp formats or how the level filter interacts with the result set, leaving the baseline at 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?

Description uses a specific verb ('Query') and names an exact resource set: recorded console messages, runtime errors, and unhandled promise rejections, with stack traces. This distinguishes it from sibling tools like get_network_events and get_live_dom_snapshot, so an agent can tell what it does without inferring.

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 resource type implies when to use it (needing console/runtime diagnostic records), but there are no explicit when-to-use, when-not-to-use, or alternative routing statements. With many sibling tools present, this guidance is only implicit 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 behavioral disclosure burden. 'Inspect' and the property list imply a non-mutating read operation. However, it does not disclose behavior for missing nodes, selector/nodeId precedence, or time out-of-range conditions, though these are not critical for a read-only inspection.

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

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

A single sentence with no filler; the action, target, temporal scope, and property list are all front-loaded and useful.

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 description is adequate for a simple inspection tool, but with no annotations and no output schema, it leaves behavior under-specified (e.g., how nodeId and selector interact, missing-node handling, and any distinction from the many sibling DOM inspection 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 schema already explains all four parameters. The description adds which properties will be inspected, enriching the expected result, but does not add new meaning about nodeId vs selector or timestamp semantics 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?

The description clearly identifies the operation as inspecting detailed properties of a specific DOM node at a timestamp, and lists the property categories. It distinguishes itself through 'specific' and 'at a given timestamp' from live/snapshot siblings, but does not explicitly name an alternative tool.

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

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

There is no guidance on when to choose this tool over the many siblings (e.g., get_dom_subtree, inspect_live_element, get_live_dom_snapshot). The 'given timestamp' implies historical inspection, but no when-to-use or when-not-to-use conditions 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?

No annotations are provided, so the description carries the full burden. It discloses the checkpoint delta replay mechanism, which is a meaningful behavioral trait, but it does not mention performance costs, limitations of the reconstructed snapshot, or whether the operation has side effects (though it appears read-only).

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 contains the core purpose, key input concept (timestamp/event ID), and the method (checkpoint delta replay). Every word contributes; there is 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?

The description sufficiently covers what the tool does and the method, and the schema handles parameter documentation. However, it does not explain what happens when neither timestamp nor eventId is provided (e.g., does it default to latest state?), nor does it give any guidance on interaction with the many sibling tools, making the definition incomplete for an agent deciding how to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds the concept of 'arbitrary timestamp or event ID', aligning with timestamp and eventId, but does not provide additional semantic detail beyond the schema's property descriptions.

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

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

The description uses a specific verb ('Reconstruct') with a precise resource ('complete DOM snapshot') and a distinctive mechanism ('checkpoint delta replay'). This clearly differentiates the tool from live snapshot, node-specific, and diff-focused siblings.

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 historical reconstruction at a specified timestamp or event ID, which provides context for when the tool is appropriate. However, it does not explicitly state when to prefer this tool over alternatives like get_live_dom_snapshot or get_dom_subtree, nor does it mention any 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 must convey behavioral traits itself. 'Reconstruct' communicates that the HTML is rebuilt from recorded session data and the output is HTML. However, it does not disclose behavior on missing nodes, invalid timestamps, or whether extraction has side effects, leaving some uncertainty.

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 concise sentence that front-loads the action and object, includes concrete examples for subtree selection, and specifies the temporal scope. There is no redundant or wasted 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?

The description identifies the output (HTML) and the historical context, which is enough for a basic call. Yet it does not clarify how nodeId and selector relate, nor that only sessionId is required, leaving ambiguity about defaults when both selector and nodeId are omitted.

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 four parameters; the baseline is 3. The description adds useful examples of subtree selectors and reinforces the timestamp concept, but does not substantially extend parameter 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?

Clearly identifies a specific operation: reconstruct and extract the HTML of a subtree at a historical timestamp, with concrete examples (#app or .gpt-panel). The timestamp qualifier distinguishes it from sibling get_live_dom_subtree, making the purpose 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 'at a given timestamp' clearly signals this is for historical/replay DOM extraction rather than live inspection, providing useful selection context. It stops short of explicitly naming get_live_dom_subtree as the live alternative or stating when not to use this tool.

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 burden of behavioral disclosure. It clearly indicates a read-only inspection operation and enumerates the specific visual aspects inspected, which gives the agent an accurate mental model. It does not disclose error behavior or the need for a live debugging connection, but the core behavior is well conveyed.

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. Every word contributes to specifying what the tool inspects and in what context, making it efficient and easy to parse.

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 description is sufficient for understanding the tool's core purpose and output themes, especially given the schema covers parameters. However, it does not clarify which of nodeId or selector should be supplied when both are optional, how the tool selects the element if both are provided, or how this differs from inspect_live_element. These gaps are notable given the rich sibling list.

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 both nodeId and selector already documented. The description adds no further parameter-level detail, which is acceptable since the schema fully covers parameter meaning. The baseline of 3 applies 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?

The description names a specific verb ('Inspect') and a precise resource: detailed visual layout, occlusion, clipping, opacity, z-index, and viewport visibility for a live element. This clearly separates it from DOM-oriented siblings like get_dom_state and get_live_dom_snapshot, and from screenshot tools.

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 a live element' implies this tool is for inspecting elements in the live page rather than session snapshots, which is useful context. However, it does not explicitly state when to prefer this over inspect_live_element or get_selected_element, nor does it give exclusions or alternatives.

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 present, so the description carries the full burden of behavioral disclosure. It only says 'query' and lists filters; it does not mention default limits, pagination behavior, result ordering, whether filters combine, or what the response contains. For a 10-parameter tool this is a significant gap.

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

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

The description is a single concise sentence with no filler. It front-loads the action and resource, followed by a compact list of filter capabilities. It could be slightly more informative without losing 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?

Given the tool's complexity (10 parameters, no output schema, no annotations), the description is too minimal to be complete. It does not explain how filters combine, the default limit, pagination semantics, or the shape of returned events. The 100% schema coverage helps with parameter syntax but does not fill the behavioral and contextual 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 the schema already documents all parameters. The description adds some useful grouping and examples (categories like DOM, USER, ERROR, CONSOLE, NETWORK), but it largely paraphrases the schema without adding deeper meaning about parameter interactions or formats.

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

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

The description clearly states the tool 'Query recorded events' and enumerates the main filter dimensions (category, type, timestamp range, target node, search query). It is specific enough to convey the core purpose, though it does not explicitly differentiate from siblings like get_events_around or get_network_events.

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 about when to use this tool versus alternatives such as get_events_around, get_timeline, or get_network_events. The filtering list implies general usage, but no exclusions, prerequisites, or sibling routing 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?

With no annotations, the description must carry the behavioral burden. It communicates that this is a read-only retrieval operation, but it does not disclose what happens when neither timestamp nor eventId is provided, whether the parameters are mutually exclusive, or how the window boundary is treated. The 300ms default is only visible in the schema, not reinforced here.

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 front-loads the core operation and scope, earning every word.

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 four parameters, only one required, and no output schema, the description is too thin. It does not clarify whether eventId and timestamp are alternatives, what the default behavior is when neither is supplied, or what the returned 'contextual window' contains, leaving an agent to guess at invocation details.

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 four parameters. The description adds only mild context by tying eventId and timestamp to the notion of a 'specific' target and 'immediately before and after', but it does not explain the relationship or precedence between the two optional target 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 clearly identifies a specific verb ('Retrieve'), a resource ('events'), and a precise scope (immediately before and after a timestamp or event ID). This distinguishes it from generic sibling tools like get_events or get_timeline by emphasizing the localized 'window' nature.

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 tool should be used when an agent needs a contextual window around a specific timestamp or event ID, but it provides no explicit guidance about when to prefer this over siblings like get_events or get_timeline, and no exclusions or alternatives are 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 behavioral disclosure burden. It states that the tool captures a live snapshot, which reasonably implies a non-mutating read operation, but it does not explicitly disclose side effects, prerequisites like an active live inspection session, or the structure of the returned JSON. The 'snapshot' phrasing mitigates some of the ambiguity, but additional behavioral detail would be better.

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 concise sentence that immediately states the action, target, and output formats. There is no fluff, repetition, or unnecessary detail, making it easy for an agent to parse quickly.

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

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

For a tool with only one optional parameter and no output schema, the description covers the essential facts: what is captured, from where, and in which formats. It does not mention the default format or explicitly clarify relationship to sibling tools, but the schema covers the default and the operation is simple enough that the description is largely sufficient.

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

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

The input schema has 100% description coverage, with the `format` parameter already clearly documented as an enum with a default of 'html'. The tool description largely repeats these format options rather than adding new meaning, so it meets the baseline but does not elevate parameter understanding.

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

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

The description uses a specific verb ('Capture') and clear resource ('current live virtual DOM state snapshot of the active browser page') and explicitly mentions the available output formats. It does not explicitly differentiate itself from siblings like get_dom_state or get_live_dom_subtree, though 'current live' and 'active browser page' imply a 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 implies the tool should be used when a current live DOM snapshot is needed, but it gives no explicit guidance about when to prefer this over the `get_dom_state` or `get_live_dom_subtree` siblings. No alternatives or exclusions are mentioned, so usage context 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 must carry the full behavioral transparency burden. It hints at read-only extraction but does not explicitly state side effects, freshness guarantees beyond 'live', output format, or behavior when the subtree cannot be found.

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, well-structured sentence with no filler. The key terms 'live HTML', 'node structure', and 'specific subtree' are front-loaded and immediately tell the agent what the tool operates on.

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 relatively simple tool with only two documented parameters, the description gives enough initial scoping, but important gaps remain: there is no output schema, no detail on the returned HTML/node representation, and no guidance on how to resolve the ambiguity of two optional identifying parameters (nodeId vs selector).

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 nodeId and selector are already clearly described as the subtree root. The description does not add additional meaning about how these parameters interact, which one is preferred, or what happens if both are omitted, so the baseline score 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 states a specific action (reconstruct and extract), a clear resource (live HTML or node structure of a subtree), and a clear scope (active browser page). It also differentiates from sibling tools by combining 'live' and 'specific subtree', helping distinguish it from get_dom_subtree and get_live_dom_napshot.

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

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

The description implies when it should be used—when a specific live subtree is needed—but offers no explicit guidance on when to choose this over get_dom_subtree, get_dom_node, or get_live_dom_snapshot. No alternatives or exclusions are mentiond.

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 behavioral disclosure. 'Query recorded' reasonably implies a read-only operation, and 'correlated with timing and duration' adds useful context. However, it does not mention output shape, pagination, or any edge-case behavior, so coverage is adequate but not rich.

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 conveys the core purpose without filler. Every word contributes: the resource, the scope, and the timing/duration correlation.

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 query tool, the description gives enough context to understand what is returned: network requests and responses with timing/duration correlation. The absence of an output schema is partly mitigated by this stated return focus, though explicit list-vs-single and ordering details would make it fully 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 input schema already documents both parameters adequately. The description adds general context about network requests and timing but does not add meaning beyond what the schema provides, which matches the baseline score.

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

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

The description uses a specific verb ('Query') and resource ('recorded network requests and responses') and adds a distinguishing characteristic ('correlated with timing and duration'). This clearly separates it from generic event tools like get_events or get_timeline.

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

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

The description implies when to use the tool: when network request/response data is needed. However, it does not explicitly state when not to use it or name alternatives such as get_timeline or get_diagnostics, leaving selection logic to inference.

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

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

With no annotations, the description carries the full burden of explaining behavior. It does disclose the audit criteria (monotonicity, missing nodes, capability health), but it does not state whether the operation is strictly read-only, whether it has side effects or costs, or what the response contains. The 'get_' prefix implies non-mutating, but the description does not confirm 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?

One sentence with no filler. The action is front-loaded, and the rest names concrete audit checkpoints. Every word earns its place, making the description efficient and easy to scan.

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

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

For a single-parameter tool, the description is mostly sufficient for selecting and invoking it: it names the parameter's role and the audit criteria. However, since there is no output schema and no annotations, it does not explain the return format or how to interpret the audit results, leaving a meaningful gap 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?

The schema already documents sessionId with 100% coverage as 'Session ID'. The description adds the context that the session is a recording session, but it gives no additional format, constraints, or usage 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?

The description states a specific verb ('Run an automated integrity audit'), a resource ('recording session'), and the specific checks ('sequence monotonicity, missing nodes, and capability health'). It clearly explains what the tool does, though it does not explicitly distinguish it from the similar get_diagnostics 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?

Usage is implied: call this when you need an automated integrity audit of a recording session. However, there is no explicit guidance about when to prefer this over sibling tools like get_diagnostics or get_session, and no exclusions or prerequisites 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?

No annotations are provided, so the description must carry behavior disclosure. It communicates that the tool is a read-only listing operation scoped to a recording session, but it does not describe the returned checkpoint structure, whether it returns metadata or image data, or behavior for empty or missing sessions. This is adequate but not richly transparent.

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 with no filler. The key action and resource are front-loaded, and every word contributes to identifying what the tool does, making it appropriately concise for a simple listing 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 one-parameter list operation with no output schema or annotations, the description gives enough to select the tool: it names the resource and scope. However, it does not explain what distinguishes 'visual checkpoints' from 'screenshot checkpoints,' what fields are returned, or how results are ordered or served, leaving some ambiguity 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?

The input schema already fully describes sessionId ('Session ID') with 100% coverage. The description adds only that the session is a 'recording session,' which is minor contextual value beyond what the schema provides. 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?

The description uses the specific verb 'List' and names the resource ('visual checkpoints and screenshot checkpoints') with the scope 'captured during the recording session.' This clearly differentiates it from the capture_* sibling tools, which take live screenshots rather than listing recorded checkpoints.

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

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

There is no explicit when-to-use guidance or mention of alternatives such as capture_page_screenshot or get_timeline. The phrase 'captured during the recording session' implies this is for already-recorded session data, but the description does not state when to prefer it over related tools or when not to use it.

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 itself. 'Retrieve' communicates that this is a read operation, and the selection mechanism is stated. However, it does not mention what happens if no element is selected, whether it can return null/error, or any other runtime 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?

The description is a single, front-loaded sentence with no redundant words. Every phrase adds meaning: retrieve, DOM element, visually selected, user, Ctrl+Shift+Mouse Click, live browser.

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 zero parameters, no annotations, and no output schema, the description still communicates enough: what is being retrieved, how the selection happened, and where it happens. For this simple getter, the description is complete enough for an agent to invoke it correctly.

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

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

The schema has zero parameters, so there are no parameter details to document. Baseline for zero-parameter tools is 4, and the description adds relevant context about the user-driven selection mechanism that caused the element to exist.

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

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

The description uses a specific verb ('Retrieve'), names the resource ('DOM element'), and specifies the exact selection mechanism (Ctrl + Shift + Mouse Click in the live browser). This clearly distinguishes it from siblings like start_element_picker or inspect_live_element because it is specifically about retrieving a user-selected element.

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

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

The description clearly implies the tool should be used only after the user has visually selected an element in the live browser. It does not explicitly exclude alternatives or mention when not to use it, but the precondition is clear enough for correct 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. The verb 'Retrieve' clearly signals a non-mutating read operation, and the description enumerates what will be returned. It does not discuss failure conditions or payload size, but that is acceptable for a straightforward getter.

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 sentence with no filler. The action, target, and return categories are all front-loaded, and every word contributes to the agent's understanding.

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 read tool with no output schema, the description gives a complete high-level contract: it states the input (via schema) and the return categories (metadata, capabilities, health, statistics). It could be more complete by explicitly noting non-destructive behavior or naming relevant siblings, but nothing essential is missing for selection and invocation.

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

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

The only parameter, sessionId, is already fully documented in the schema with 100% coverage, and the description adds no additional parameter-level meaning. Per the baseline for high schema coverage, this is correctly rated at 3.

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

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

The description opens with a specific verb ('Retrieve') and clearly identifies the resource ('a specific debugging session') and the data categories returned (metadata, capabilities, health status, statistics). This distinguishes it from siblings like list_sessions (collection) and delete_session (mutation) without needing to open their schemas.

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 'specific debugging session' implies this is the point-lookup counterpart to list_sessions, but the description never explicitly says when to use it versus alternatives such as get_recording_health or get_diagnostics. Usage guidance is present only by implication, not direct instruction.

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 bears the full burden of behavioral disclosure. It does disclose the return content (summary breakdown, categories, milestones) and implies a read-only operation through the verb 'Retrieve', which adds value beyond the name. However, it does not address behavior for missing/invalid sessions, whether results can be filtered, or any limits on the timeline scope.

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, well-structured sentence that front-loads the primary action and outcome. Every phrase contributes meaning — there is no filler, and the key distinction ('summary breakdown') appears early.

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 read tool with no output schema, the description adequately covers what the tool returns and at what granularity. The only notable omission is routing guidance to get_events for raw event detail, but that is more a usage-guideline concern than a completeness gap for a tool this simple.

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 sessionId fully. The description adds only a loose contextual tie between the parameter and the timeline ('across the session timeline'), which is marginal enrichment. The baseline 3 is appropriate when the schema carries the parameter documentation burden.

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 ('Retrieve') and a distinct resource ('summary breakdown of events across the session timeline'), and specifies the contained content ('event categories and significant milestones'). This clearly conveys it is a summary-level view, implicitly distinct from raw event tools like get_events, though it does not explicitly name that 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 gives no when-to-use or when-not-to-use guidance. It does not mention alternatives such as get_events for raw event data, nor does it state any conditions that should route an agent to this tool over its siblings. Usage intent must be inferred solely from the word 'summary'.

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 states that a bundle is imported, but does not say whether this creates a new session, overwrites an existing one, validates the JSON, or has other side effects. For a potentially destructive import operation, 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?

The description is one clear, front-loaded sentence with no filler. It communicates the core operation and input format efficiently.

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, and the tool description is minimal. Important context is missing, such as whether the import replaces or appends, what happens on invalid input, what the return value is, and any prerequisites. An agent cannot reliably determine the full behavior from this definition 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?

The schema description for bundleJson ('Raw JSON string of the session bundle') fully covers the single parameter, and the tool description adds little beyond that. With 100% schema coverage, a 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 states a specific verb ('Import') and resource ('recording session bundle') and clarifies the input format ('from raw JSON string'). This clearly distinguishes it from sibling tools like export_session and list_sessions.

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 export_session or list_sessions. There is no mention of typical use cases, prerequisites, or situations where this tool should or should not be used.

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 behavioral disclosure burden. It clearly states that inspection operates on the live page and enumerates the returned dimensions: bounds, computed styles, visibility, attributes, state, role, aria, and parent context. This is substantial, though it does not mention error behavior or side effects; 'inspect' reasonably signals read-only intent.

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

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

The description is a single compact sentence that front-loads the action and resource before listing output categories. Every phrase contributes useful information, and there is no repetition of the tool name or schema content.

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 must stand alone, and it does list many return categories. However, it does not state that at least one locator parameter is expected when the schema marks all four as optional, and it omits xpath from the accepted locator modes. These are material invocation gaps, making the description minimally viable but not 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?

The input schema already documents all four parameters at 100% coverage, which sets a baseline of 3. However, the description enumerates only selector, LogicalNodeId, and selectedElementRef, silently omitting xpath. This inconsistency could mislead an agent into believing XPath targeting is unsupported, so the description actively detracts rather than adding value.

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 ('deeply inspect') and resource ('live DOM element on the active browser page'), and enumerates both locator modes and rich output categories. This makes the tool's purpose immediately distinct from page-level or snapshot siblings even though it does not name 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 'live DOM element on the active browser page' language implies when the tool is appropriate, but the description gives no explicit when-to-use or when-not-to-use guidance and does not mention alternatives such as inspect_live_page, trace_element, or get_element_visual_state. Context is clear, but routing among siblings is left to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The word 'Inspect' and 'current live' imply a read-only snapshot of live state, but the description does not explicitly state that the tool has no side effects, does not modify the page, or may reflect transient loading states. This is adequate but not rich.

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

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

A single sentence that front-loads the primary action and scope, then efficiently enumerates the covered state fields in a colon-separated list. There is no filler, repetition, or unnecessary detail.

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

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

For a zero-parameter inspection tool, the description is largely complete: it names the main resource and the important included fields. However, there is no output schema and no explicit statement of return shape or element representation, so an agent must infer some details about how active/focused elements are identified.

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

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

The tool has zero parameters, so there is no parameter ambiguity for the description to clarify. The baseline for zero parameters is 4, and the description appropriately focuses on what the tool returns rather than on input 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?

The description uses a specific verb ('Inspect') and resource ('current live browser page state'), and enumerates concrete data points: URL, title, viewport dimensions, scroll positions, readyState, active and focused elements. This clearly distinguishes it from page-level siblings like get_live_dom_snapshot or get_dom_state, which focus on DOM structure rather than overall page 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 implies use when an agent needs current page-level state details, but it never explicitly says when to prefer this tool over alternatives like get_live_dom_snapshot, inspect_live_element, or get_element_visual_state. There are no exclusions or sibling comparisons, so usage guidance is only implicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose that the tool acts on a live element and returns before/after state and effect measurements, which is useful. However, it does not warn about side effects such as page navigation, irreversible mutations, or failures despite actions like click, clear, and press_key being potentially destructive.

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 sentence with no filler, front-loaded with the operation, and the parenthetical action list is dense but directly relevant. It earns its place without redundant phrasing.

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 tool with 10 parameters, a nested scrollDelta object, conditional per-action requirements, and no output schema, yet the description is only one sentence. It does not explain element targeting options or which parameters are required for which actions, and there are no annotations to compensate.

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 baseline is 3 and the schema already documents each parameter. The description mostly repeats the action enum and does not add meaning about action-specific parameter dependencies such as press_key needing key, select_option needing optionValue, or scroll needing scrollDelta.

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 concrete operation ('Perform an interaction') on a specific target ('a live element'), enumerates all 12 action types, and states the return value ('before/after state and effect measurements'). This clearly distinguishes it from sibling read-only or inspection tools like get_dom_node or inspect_live_element.

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 usage through the action list and 'live element' phrasing, but it does not explicitly state when to use this tool over alternatives, nor does it mention any exclusions or when not to use it. No sibling tool is referenced as an alternative, so the agent must infer the intended 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 behavioral disclosure burden. It does disclose the read-only listing nature, the 'all sessions' scope, and the included field types. It does not mention ordering, pagination, or potential performance impact, though the optional limit parameter in the schema partially covers 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 a single front-loaded sentence that efficiently communicates the action, resource scope, and return fields. There is no filler or redundancy, and every word adds value.

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 listing tool with one optional, schema-documented parameter and no output schema, the description gives enough context to invoke it correctly: it names the resource, the scope, and the returned content. Minor details like ordering or multi-workspace behavior are absent but not critical for this 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?

The only parameter, limit, is already fully documented in the schema as 'Maximum number of sessions to return', giving 100% schema description coverage. The tool description adds no additional parameter semantics, but the schema already provides the necessary meaning.

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 action ('List'), a specific resource ('all recorded browser forensic debugging sessions'), and the content returned ('metadata, timestamps, and stats'). This clearly distinguishes it from singular tools like get_session and from mutation tools like delete_session.

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 that this tool is for retrieving all sessions, which an agent can infer from the word 'all' and the sibling tool context. However, it never explicitly states when to use this tool versus alternatives such as get_session or export_session, nor does it list 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 of behavioral disclosure. It reveals that observation is continuous and scoped to subtree/ancestors, but omits side effects, duration, idempotency, prerequisites for identifying the element, and how observation ends.

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 concise, front-loaded sentence with no redundant wording. It is appropriately sized and every word contributes 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?

Given no output schema and no annotations, an agent needs more context: how to choose the target when required parameters are zero, what continuous observation implies for resource use, and how to stop it. The sibling set shows related observation tools, but the description does not mention them or the overall workflow.

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 adds little beyond 'target element' and does not clarify whether nodeId and selector are alternative or complementary ways to identify the target, especially since neither param is required.

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

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

The description uses a specific verb ('Start') and resource ('focused continuous recording and observation') and scopes it to a target element plus its subtree/ancestors. It is clear, but it does not explicitly distinguish this from sibling tools like start_element_picker or trace_element.

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 'continuous recording and observation' implies this is for long-lived observation of an element, which is the correct context. However, it gives no explicit when-to-use guidance, no exclusions, and no mention of the matching stop_element_observation tool that would complete the workflow.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It does describe the interactive mode and its visual affordances, but it omits important state-related behaviors: the picker persists until stopped, the browser can be affected by the overlay, and no mention is made of how the selected element is returned or consumed.

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. Every phrase adds meaning: activation, interactivity, visual mode, live browser, hover highlighting, and click selection.

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 with one optional parameter and no output schema, so the core action is adequately described. However, because the action starts a persistent mode, the description should mention the need to stop the picker or reference the sibling stop_element_picker and get_selected_element to be fully complete for an agent deciding how to sequence calls.

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% for the only parameter (highlightColor), so the schema already documents it. The description adds no additional parameter semantics, which is acceptable given the complete 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 uses a specific verb ('Activate') and a clear resource ('interactive visual element picker mode'), and adds concrete behavioral details ('hover highlighting and click selection'). This clearly distinguishes it from related tools like stop_element_picker or inspect_live_element.

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 usage: it is for activating a picker mode in the live browser. However, it does not explicitly state when to prefer this over alternatives, nor does it mention lifecycle pairing with stop_element_picker or retrieving a selection via get_selected_element.

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

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

With no annotations present, the description carries the full burden and does provide meaningful behavior beyond the name: it will stop observation and generate a bundle containing mutations, diagnostics, network activity, and root-cause analysis. It does not however disclose side effects, whether existing observation sessions are terminated globally, or any irreversible 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?

A single, front-loaded sentence states the action first and then the output. Every part adds information, with no redundancy or 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 zero-parameter tool, the description covers both the action and the content of the returned bundle, which is especially important given there is no output schema. It could be slightly more complete by explicitly linking to start_element_observation, but the sibling list and the wording make that connection clear.

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

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

The tool has zero parameters, so there are no parameter semantics to explain. The description focuses instead on behavior and output, which is appropriate and leaves no parameter-related gaps.

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 action and resource: 'Stop focused element observation' and then specifies the expected output ('assemble a complete correlation bundle...'). It is clearly distinguishable from sibling tools like stop_element_picker and is the natural counterpart to start_element_observation.

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 implicitly signals that this tool is used to end a focused element observation and produce a summary bundle. However, it does not explicitly state when to use it versus alternatives such as stop_element_picker or inspect_live_element, nor mention prerequisites like a prior start_element_observation call.

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

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

With no annotations present, the description carries the behavioral disclosure burden. It clearly states the effect: deactivating picker mode and restoring normal cursor/interaction state. It does not mention edge cases such as idempotency or behavior when no picker is active, but for a simple state-toggle tool the disclosed behavior is sufficient.

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, well-structured sentence that front-loads the action and clearly states the outcome. Every word earns its place with no redundancy or 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 parameterless tool with no output schema, the description is complete. It explains what the tool does and what state change occurs, and sibling tools provide sufficient surrounding context. Nothing essential is missing.

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

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

The tool has zero parameters, so the schema is trivially complete. The baseline for zero-parameter tools is 4, and the description adds no unnecessary parameter information, 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?

Description uses a specific verb (Deactivate) with a clear resource (visual element picker mode) and states the resulting state change (restore normal cursor and interaction state). It clearly differentiates itself from siblings like start_element_picker by being the inverse operation.

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

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

Usage context is implied: the tool should be used when the visual element picker mode is active and needs to be turned off, especially after calling start_element_picker. However, no explicit when-to-use or alternative routing is provided, so the guidance is inferred 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It explains the scope of the trace (creation, mounting, mutations, style changes, removal) and implies a read-only operation, but it does not disclose what the tool returns, whether a recorded session is required, how data is ordered, or any limitations. This is partially transparent but leaves key behavioral aspects unspecified.

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, tightly written sentence. It front-loads the verb and resource and packs the lifecycle scope into a compact list without unnecessary words. Every part 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 description covers the core purpose but leaves gaps: no output schema and no mention of return format, ordering, or prerequisites. Given the complexity of tracing a lifecycle and the absence of annotations, an agent would benefit from knowing whether historical recording is required, how the result is presented, and whether it works for live elements. This is adequate but not 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 documents nodeId, selector, and sessionId well. The description does not add parameter-level meaning beyond the schema, and the mention of lifecycle milestones doesn't clarify which parameter combination is sufficient (e.g., nodeId vs selector). Baseline 3 is appropriate because the schema handles parameter 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?

The description uses a specific verb ('Trace') and a specific resource ('DOM element') and scopes the behavior to the entire chronological lifecycle—creation, mounting, mutations, style changes, unmounting/removal. This is much more precise than sibling tools like get_dom_state or get_dom_node and clearly distinguishes what this tool covers.

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 use case (need lifecycle history of an element), but it does not explicitly state when to use this over alternatives like get_events, get_timeline, or why_did_element_disappear. No exclusions or alternative routing are provided, so an agent must infer the appropriate 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It usefully lists the diagnostic dimensions it can report: removal mechanism, ancestor container destruction, style changes, and correlated errors/network triggers. However, it does not state whether the operation is read-only, what kinds of limitations exist, or what the output format will be.

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 dense sentence with no filler. The purpose is front-loaded ('Forensic root-cause diagnosis') and each phrase contributes meaning: injected/existing, disappeared, removal mechanism, ancestor container destruction, style changes, and correlated errors/network triggers.

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 description provides enough orientation for an agent to decide when to invoke the tool and what it will return conceptually. It covers the tool's focus areas, and the 100% parameter schema coverage handles invocation details. The only gap is the absence of an explicitly described output shape, but the listed diagnosis dimensions largely compensate for the missing output schema.

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

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

Schema description coverage is 100% for the two parameters, so the schema already fully documents sessionId and target. The description adds no parameter-specific guidance beyond the contextual phrase 'target element', which is already covered by the schema's own 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 description uses a specific verb phrase ('Forensic root-cause diagnosis') and clearly identifies the resource and outcome: determining why an injected or existing UI element disappeared. It also differentiates the tool from session-management siblings by focusing on disappearance cause analysis.

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

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

The description implies when to use the tool (whenever a UI element disappeared and the cause is unknown), but it does not explicitly state when not to use it or name alternatives such as get_element_visual_state or get_live_dom_snapshot. The usage context is inferrable but not made explicit.

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