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

No annotations are provided, so the description carries the full burden and does well: it discloses the return envelope ({events, last_seq}), the cursor-based incremental retrieval pattern, and the retention limitation that state does not survive server restarts. It stops short of describing event `kind` values or ordering guarantees.

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?

Four tight sentences, front-loaded with what the tool returns, then the cursor mechanism, then the retention caveat. No filler, no restatement of the tool name.

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

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

With no output schema, the description supplies the response shape and cursor semantics, plus the lifecycle limitation — everything needed to invoke and iterate correctly. Minor gap: the set of possible `kind` values is elided as "...", which could matter for client-side filtering.

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

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

Schema coverage is 0%, so the description must compensate, and it does: `since` is defined as a sequence number, and the round-trip use of `last_seq` gives a concrete value to pass. Only the default-0 baseline behavior (fetch everything retained) is left implicit.

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

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

States a specific verb and resource: retrieves self-initiated messages TTSim emitted (print output, Lua errors, game loaded/saved, object creation). This clearly separates it from siblings like get_scripts (script inventory) and run_lua (execution), which do not describe an event stream.

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?

Explains the polling pattern explicitly: pass the returned `last_seq` as `since` next time to get only new events. It also states the key exclusion — only events received while the server runs are available — so the agent knows not to rely on history. It doesn't contrast with sibling tools, but the usage context is clear.

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 disclosure burden and does meaningful work: it declares read-only semantics, describes the exact return shape, and states the non-obvious filtering rule that only objects with non-empty script or UI are listed. It does not cover behavior when no game is loaded or output size concerns, keeping it short of a 5.

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

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

Three compact lines: purpose first, then the return contract, then the filtering caveat. No filler, and the most decision-relevant fact (read-only) is front-loaded.

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

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

No output schema exists, so the description's inline return shape is essential and adequate, and with no parameters and no annotations there is little else to document. It stops just short by not stating prerequisites (a loaded game) as a failure mode or hinting at output volume for large games.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description correctly implies there is no filtering or scoping argument beyond the implicit 'loaded game' context.

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

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

States a specific verb and resource: read the loaded game's Lua scripts and UI XML, with an explicit read-only marker. It is clearly distinct from the mutating/executing siblings like run_lua or move_object, though it never names them directly.

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

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

The intent of reading scripts is implied by the name and description, but there is no explicit when-to-use statement and no routing against alternatives such as inspect_object (single object) or run_lua (execute rather than read). Usage must be inferred.

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

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

With no annotations, the description carries the full burden; it does disclose that the effect is visual and short-lived ("for a few seconds"), which implies a safe, non-mutating operation. It does not say whether the object/player must be present, what happens with an invalid guid, or whether the call blocks for the duration.

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

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

Two short sentences, purpose front-loaded, with the parameter detail following. The colour list trails off with an ellipsis but the enumeration is genuinely useful rather than 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 3-parameter, no-output, no-annotation tool the description covers purpose, colour naming, and approximate duration, which is enough to call it. It leaves open where the guid comes from and what the call returns or does on failure, which matters with zero annotation coverage.

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

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

Schema description coverage is 0%, so the description must compensate. It does well on `color` (TTSim colour name with an example list) and implies `seconds` via "a few seconds", but gives no meaning for `guid` (presumably an object GUID from list_objects) and no units or bounds for `seconds`.

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

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

The description gives a specific verb and resource ("Highlight an object") plus the player-facing effect and duration, which clearly separates it from siblings like move_object or inspect_object. It stops short of naming any sibling directly, so it is clear but not fully differentiated.

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

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

The phrase "to point it out to the player" implies the usage context (visual attention cue during play) but there are no explicit when/when-not rules or pointers to alternatives such as inspect_object for non-visual inspection. Usage must be inferred.

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 burden and does a good job disclosing the returned data: scale, bounds, value, held/moving state, and snap points. It implies a read-only inspection but does not explicitly state side effects, permissions, or error behavior.

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

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

The definition is front-loaded with the core purpose, then efficiently lists the additional details returned. Every clause adds information and there is no redundant or filler text.

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 inspection tool with no output schema or annotations, the description is largely complete because it explains the rich return contents. It still omits error behavior and does not describe the guid parameter.

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

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

Schema description coverage is 0%, so the description should compensate for the undocumented guid parameter. It says the tool inspects one object but never names or explains the guid, leaving parameter meaning entirely to the bare schema field.

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

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

The description states a specific verb and resource: it returns full details for one object. It explicitly distinguishes itself from list_objects by saying it gives everything list_objects gives plus additional per-object data.

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

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

The contrast with list_objects makes the intended use clear: list_objects is for listing, while inspect_object is for deep inspection of a single object. It does not explicitly state when not to use it or prerequisites such as needing a guid.

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 supplied, the description carries the burden and does most of it: it discloses the record shape returned, that name matching is case-insensitive substring, tint is a hex string, and critically that GUIDs are session-volatile. It never explicitly says the call is read-only or describes result limits, which keeps it from a 5.

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

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

Two sentences, front-loaded with the resource and return shape, then the optional filters and the session caveat. Every clause carries information an agent needs; nothing is redundant with structured fields.

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

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

No output schema exists, and the description compensates by enumerating the returned fields, which is exactly right. Filters are covered. What's missing is anything about ordering, result caps, or what 'tag' accepts, which matters for a list tool an agent may call repeatedly.

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

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

Schema description coverage is 0%, so the description must compensate entirely, and it does: all four parameters (name, type, tag, tint) are named with matching semantics, including an example value for type ("Dice") and the hex format for tint ("bbbbbb"). The only thin spot is tag, whose valid values are unstated, but every parameter is at least semantically defined.

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

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

States a specific verb and resource ('List objects on the table') and immediately enumerates the returned fields (guid, name, description, type, tags, tint, position, rotation, locked, resting). This is clearly distinguishable from the inspection/mutation siblings (inspect_object, move_object) without opening any schema.

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

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

Filter semantics are explained and there is useful workflow advice ('GUIDs change when a game is loaded, so look objects up each session'), which tells the agent to re-query rather than cache. However, it never states when to prefer this over inspect_object or move_object, and nothing is said about result size or pagination limits.

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

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

With no annotations provided, the description carries the full behavioral burden. It usefully defines the return metrics (center, edge, dx, dy, dz) and clarifies edge behavior when bounding boxes overlap, but it omits error handling, required permissions, and whether missing objects cause failures.

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 two tight sentences: the first states the measurement and input forms, and the second defines the returned components. Every phrase is informative and the purpose is front-loaded.

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 measurement tool with no annotations or output schema, the description supplies the essential input formats and return metrics. It is nearly complete for invocation, though it could mention failure behavior or whether points are interpreted as world coordinates.

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

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

Schema description coverage is 0%, so the description must compensate. It adds valuable meaning by explaining that each argument can be an object GUID or a point array in [x, y, z] form, but it does not explicitly map this to parameters a and b or specify whether mixed argument types are allowed.

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

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

The description clearly states a specific operation: measuring horizontal distance between two objects (GUIDs) or points ([x, y, z]) in world units. It is distinct from sibling tools like move_object or table_geometry, though it does not explicitly name alternatives.

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

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

The description explains what the tool does but gives no guidance on when to use it versus alternatives such as table_geometry or inspect_object. There are no exclusions, prerequisites, or usage conditions 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 burden and does well: it discloses that the call blocks until the object settles, that smooth=true glides versus false teleporting, and that final position and rotation are returned. It omits permissions, failure behavior, and whether coordinates are world or local space.

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?

Four short sentences, front-loaded with the action and its blocking behavior, then the smooth toggle, then a practical tip. No filler and every sentence adds information an agent would otherwise have to guess.

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 4-parameter mutation tool with no annotations and no output schema, the description covers blocking semantics, the default behavior toggle, and the return value. The remaining gap is the coordinate space and the meaning of `guid`, which an agent must infer.

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

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

Schema coverage is 0%, so the description must compensate. It explains `smooth` meaningfully (glide vs teleport, default true) and clarifies that `rotation` is optional, but adds nothing on `position` format, coordinate frame, or what `guid` identifies — the other half of the parameters remain undocumented.

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

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

Specific verb and resource: "Move one object to `position` (optionally `rotation`)". The phrase "one object" implicitly separates it from the sibling move_objects, though it never names that sibling explicitly. An agent can tell what it does without opening the schema.

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

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

It offers practical placement advice ("Place pieces slightly above their resting height and let physics settle them"), which is real usage guidance. But there is no explicit when-to-use / when-not-to-use statement and no routing to move_objects for multi-object moves.

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

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

With no annotations, the description must carry the full burden. 'Wait until all have settled' usefully discloses that the call is blocking/synchronous, but it doesn't cover permissions, whether motion is animated by default (smooth=true), failure behavior if a guid is invalid, or whether the move is undoable.

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?

Front-loaded action sentence followed by a tight two-branch list; every sentence earns its place. The trailing newline/formatting is slightly rough but not confusing.

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

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

A 4-parameter, zero-coverage, annotation-free mutation tool needs more: the `smooth` flag, mutual exclusivity of the two modes, and what 'settled' means operationally are all unaddressed, and there is no output schema to fall back on.

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

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

Schema coverage is 0%, so the description is the only documentation. It does add real meaning for `moves` (guid/position/rotation keys) and `offset` (dx,dy,dz formation-preserving shift), but leaves `smooth` completely undocumented and doesn't state precedence between `moves` and `guids`+`offset`.

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 ('move') and resource ('several objects at once') plus a behavioral promise ('wait until all have settled'). It implicitly distinguishes itself from the singular sibling move_object via 'several', but never names the alternative explicitly.

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

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

Clear routing between two invocation modes: explicit per-object targets via `moves`, or a shared `offset` applied to `guids` to preserve formation. No guidance on when to prefer this over calling move_object repeatedly, and no statement on what happens if both modes are supplied.

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 safety profile and does so: it declares the operation non-mutating ('without rolling') and describes what each returned item contains (value, resting, tilt, cocked, tint, position; coins report face name like "Heads"). It does not explain what the cocked_tilt threshold does or how invalid guids are handled.

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

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

Front-loaded with the core purpose and the non-rolling qualifier, then a compact enumeration of returned fields. Slightly terse on the parameter side rather than padded, so length is not the problem.

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

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

For a tool with no annotations and no output schema, the description does useful work by enumerating the per-die return fields. But it leaves cocked_tilt undefined and gives no guidance on identifier format or behavior for unknown guids, which an agent needs in order to call it correctly.

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

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

Schema coverage is 0%, so the description must carry parameter meaning. It implies the scope of 'guids' ('the given dice/coins, or all dice and coins on the table') but never states the expected identifier format, and the second parameter cocked_tilt is never mentioned at all.

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

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

States a specific verb and resource ('Read dice values') plus the key distinction 'without rolling (e.g. after the player rolled)', which separates it from the sibling roll_dice. It also clarifies it covers coins as well as dice.

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 parenthetical 'without rolling (e.g. after the player rolled)' gives clear situational context and implicitly routes the agent to roll_dice when it actually wants to roll. There is no explicit 'do not use for X' exclusion, but the alternative is obvious from the sibling name.

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

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

With no annotations, the description carries the full burden and does well: it discloses that this is a physics simulation, that it blocks until all dice come to rest, that dice bounce and can hit other objects, and that tilt/cocked disputes are possible. It doesn't cover failure modes (e.g. a die that never settles) or what happens to objects knocked over, which keeps it off a 5.

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?

Front-loaded with the mechanism, then the return contract, then the bounce caution — each sentence earns its place. Markdown mangling ('all\nhave come to rest') and the slightly run-on return sentence cost a point.

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?

Compensates well for having no annotations and no output schema by describing the return payload (value, tilt, total, `cocked`) inline. The one material omission is the identity of `guids`, which leaves an agent guessing on the required argument.

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

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

Schema description coverage is 0%, so the description must compensate. It explains `cocked_tilt` well (degrees, default 10, 'for flat surfaces') but says nothing about `guids`, the sole required parameter — an agent must guess these are the die/coin object GUIDs.

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

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

States a specific verb and resource plus the mechanism ('TTSim's physics roll (visibly lifted and spun, like pressing R)'), and distinguishes the coin/hame-face case from numeric dice. An agent can tell this apart from read_dice, which presumably only reads existing values.

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

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

Gives clear operational context: roll where nothing can be hit, e.g. in a dice tray, and notes coins are flipped with randomize rather than rolled. It never explicitly says when to prefer read_dice or another sibling over this, so it stops short of naming 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?

With no annotations present, the description carries the full burden and does well: it discloses serialization behavior (tables as JSON, scalars pass through, userdata cannot be returned), the error channel (Lua runtime/syntax errors as tool errors with the TTSim message), and the critical side effect that changes are immediately visible to players. Gaps remain around permissions, execution limits/timeouts, and whether the environment is sandboxed.

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?

Front-loaded with the core action in one sentence, then return-value rules, then error behavior, then the safety caution. The inline code example is compact and earns its place by demonstrating the userdata workaround, which would be hard to convey in prose.

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 arbitrary-code-execution tool with no output schema and no annotations, the description covers return encoding, error propagation, and mutation visibility — the essentials. It leaves out execution constraints (timeouts, permissions, sandbox scope) that an agent calling arbitrary code would want to know.

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

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

Schema coverage is 0% for the single `code` parameter, so the description must compensate — and it does, explaining that the body must use `return` to produce a value, which types serialize, and giving a concrete getObjectFromGUID example with field extraction. It stops short of stating size limits or whether top-level awaits/wait patterns are permitted.

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

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

States a specific verb and resource — execute Lua in the TTSim Global script context — and names the outcome (return the result). This clearly distinguishes it from read-oriented siblings such as get_scripts, get_events, inspect_object, and list_objects.

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 operational guidance (use `return`, how to convert userdata, errors surface as tool errors) and a caution to 'act deliberately' because changes are visible immediately. However, it never says when to prefer this over siblings like inspect_object or list_objects for simple reads, nor what to avoid running. Usage is implied rather than routed.

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 full responsibility. It discloses the return content (type, bounding box, snap points) and points to inspect_object for board snap points. It does not state that the tool is read-only or that it has no side effects, though the zero-parameter nature makes this low risk.

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 two sentences and front-loads the key information about what is returned. The second sentence is slightly fragmented ('Snap points that belong to a board are listed by inspect_object on the board') but still conveys the necessary routing information without waste.

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

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

Given zero parameters, no output schema, and no annotations, the description adequately explains what the tool returns and where board-specific snap points are found. For a simple read-only getter, this is sufficiently complete, though an explicit 'read-only' note would strengthen it.

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

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

The tool accepts zero parameters, so there is no parameter semantics to explain. Per the rubric, zero parameters yields a baseline of 4.

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 specifies the exact data returned: table type, bounding box (with center and size), and global snap points. It also differentiates from the sibling inspect_object for board-specific snap points. A clear verb like 'Get' is missing, but the resource and attributes are 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?

Usage is implied: call this tool to obtain table geometry. It explicitly tells the agent to use inspect_object for snap points belonging to a board, which is a useful exclusion. However, there is no explicit 'use this when' guidance or mention of alternatives for the table geometry itself.

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

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

With no annotations, the description carries the full burden and does well: 'Never fails: an unreachable TTSim is reported, not raised' discloses the error semantics an agent must branch on, and the return contents are enumerated. It stops short of describing the shape of the unreachable response (message text, status field), leaving that to inference.

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

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

Two sentences with no filler: capability first, error behavior second. The most decision-relevant fact (it never raises on failure) is placed where it will be read.

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 zero params, no annotations and no output schema, the description is nearly self-sufficient because it enumerates the returned fields and the failure mode. The only gap is the exact form of the 'reported' unreachable result, which an agent must guess at.

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

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

The tool takes zero parameters, so there is nothing to document and no risk of ambiguity; the baseline applies. No parameter information is needed or missing.

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 and target ('Check whether TTSim is reachable') and then enumerates exactly what is returned (game name, object count, seated players with colour and host). This clearly separates it from the sibling object/script/dice tools, which all operate on game content rather than service health.

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

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

Usage is only implied – the health-check framing suggests calling it first or when connectivity is in doubt, but the description never states when to prefer it or what to do with the result. No exclusions or alternatives are mentioned, though none of the disclosed siblings competes for the same purpose.

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