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 does communicate a main effect—freeing cells—but it does not disclose whether the session must be active, whether this is destructive/reversible, or what happens to unsaved state.

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

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

The entire description is one short, front-loaded sentence. It includes the core action and a meaningful side effect with no wasted words.

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

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

This is a simple one-parameter, no-output-schema tool, so a brief description can be acceptable. However, the lack of annotations and lack of state/error/return context leave only a minimal viable level of completeness.

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

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

The only parameter, sessionId, has no description coverage, and the description does not explain it or mention how the ID should be obtained. The parameter name is self-explanatory enough for basic inference, but the description adds no value 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 a specific verb and object: 'Close a session', and adds meaningful scope with 'free its cells.' This clearly distinguishes it from siblings like session_open, session_list, and session_set_cell.

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, when not to use it, or what alternatives exist. It does not mention whether it should be used only after a session is no longer needed, nor does it reference 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 present, the description carries the full burden and does disclose a genuine behavioral trait: referenced cells become reactive dependencies so the cell recomputes on change. It also lists per-op return types. It omits error behavior for invalid ops and whether redefining overwrites an existing cell.

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 reactive-args rule, then a tight per-op bullet list pairing args with produced value types. Dense but every line earns its place; no filler.

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

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

For a six-op dispatcher with no output schema and no annotations, the description supplies args and return shapes per op plus reactivity semantics, which is substantial. Remaining gaps are sessionId semantics, failure modes for bad ops, and overwrite behavior on redefine.

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 largely does: it enumerates every legal 'op' value with its 'args' shape, and explains the {'$cell': ...} reference syntax for args. However 'sessionId' and the 'cell' naming semantics are never explained.

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 opening line gives a specific verb+resource ('Define a computed cell from a catalog op') and the op catalog makes the scope concrete. It does not explicitly distinguish itself from close siblings like session_set_cell or session_get_cell, so an agent must infer the boundary.

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

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

Usage is implied by the op catalog rather than stated: no when-to-use/when-not guidance and no comparison against session_set_cell. The one real routing hint is 'project with session_get_cell' for opaque graph values, which points to a sibling but only for that narrow case.

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 return structure and the one-level recursion limit well, implying a safe read operation. It doesn't mention error behavior for invalid cell names or missing sessions, leaving a small 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?

Two tight sentences, front-loaded with the purpose and followed by the recursion rule. Every clause carries information; no filler.

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

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

There is no output schema, so the description must describe what is returned, and it does so precisely (role, op, args, upstream cells, values). Combined with the one-level recursion note, an agent has enough to call and iterate 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 0%, so the description must compensate for both parameters. It clarifies that 'cell' is a cell name that appears in dependency listings, which adds meaning, but sessionId is never explained and no format hints are given for either parameter.

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

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

States a specific verb and resource ('Explain a cell's own derivation') and enumerates exactly what the explanation contains: role (free input vs computed), op and raw args, immediate upstream cells with values, and current value. This distinguishes it from session_get_cell, which would only return the value.

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?

Explicitly bounds the scope ('One level only') and tells the agent how to go deeper: re-invoke on a listed dependency's cell name. It doesn't explicitly compare against sibling tools like session_get_cell or session_list_cells, but the recursion guidance is clear and actionable.

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 transparency burden. It reveals a key behavioral trait—recomputing stale values—rather than presenting a plain read, and explains rich-value projection with a concrete graph example. It does omit error/edge behaviors, but the core side-effectful recomputation is explicitly disclosed.

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 a compact illustrative parenthetical. Every clause earns its place: the core read behavior, the stale recomputation side effect, and a concrete example of the rich JSON output. No filler or restatement of the name.

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

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

For a two-parameter reader, it covers the critical behaviors (stale recompute and typed JSON projection). However, it doesn't explain the basic return format for non-rich cells, the session-open prerequisite, or failure behaviors. Since there is no output schema and no annotations, the description carries a heavier burden that it only partially satisfies.

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

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

Schema description coverage is 0% and the description does not compensate: it never explains the semantics of sessionId or cell, how cells are referenced, or what format is expected. The parameter names are somewhat self-explanatory, but the description adds no operational 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 provides a concrete action and target: 'Read a cell's current value'. It is distinct from the sibling set_cell/write operations in effect, though it does not explicitly name alternatives. The additional detail about recomputing stale values further clarifies intended semantics.

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 explicit guidance on when to use this tool versus siblings like session_set_cell or session_list_cells. It implies a read operation but does not state prerequisites, exclusions, or alternative conditions. This leaves the agent to infer usage purely from the tool name.

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

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

With no annotations, the description carries the full transparency burden. It makes the read-only list behavior clear and discloses the returned attributes, but it does not mention ordering, pagination, or other behavioral details such as whether closed sessions are excluded.

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 that starts with the action and immediately delivers the key semantic information. Every word is meaningful, with no redundancy or boilerplate.

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?

As a straightforward zero-parameter list tool with no output schema, the description is largely complete: it identifies the resource and the returned fields. A brief note on ordering or cell-level access would improve completeness, but the current information is sufficient for basic selection.

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, which matches the baseline of 4 for tools without parameters. The description needs to explain parameter-level semantics, and it does so implicitly by defining the scope of the returned list.

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 ('List') plus a specific resource ('open sessions') and even names the returned fields: kind, cell count, and creation time. This clearly communicates what the tool does and distinguishes it from sibling tools like session_list_cells, which operate on cells rather than 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?

The description gives clear context for when to use this tool—when you need a list of open sessions and their basic metadata. However, it does not explicitly state when not to use it or point to alternatives like session_list_cells for cell-level information.

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

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

With no annotations, the description carries the full burden. It discloses the output structure (role and op) but does not explicitly state that the operation is read-only, whether session must be open, or error behavior. The 'List' verb implies safety, but more could be added.

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 is front-loaded with the verb 'List' and immediately conveys the key details. 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 simple tool with one parameter and no output schema, the description covers the main function and return values, but lacks prerequisite context (e.g., session must be open) and parameter clarification. It's adequate but not 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 0%, and the description does not explain the sessionId parameter. While the name is self-explanatory, the description fails to specify that it references an existing session or how to obtain it, leaving a gap.

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

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

The description clearly states the tool lists every cell in a session, specifying the information returned (role and op for computed cells). This distinguishes it from siblings like session_get_cell (single cell) and session_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?

The description implies usage for viewing all cells in a session, but it doesn't explicitly mention when to use this over alternatives like session_get_cell. Sibling names provide context, but no direct guidance or exclusion is given.

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

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

With no annotations, the description carries the full burden and does reasonably well: it discloses that sessions are in-memory and die with the server, that seed overrides preset defaults, and that capabilities gate ops declaring requiresCapability. It omits idempotency, error behavior, and any session-count/resource limits.

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?

Dense but front-loaded: the core purpose is in the first sentence and the kind semantics immediately follow. Parenthetical asides and the cross-reference to session_define add length without being strictly wasteful, but the text is less scannable than it could be.

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

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

There is no output schema, so the description should say what opening a session returns (e.g. a session identifier needed by sibling calls) but never does. Lifecycle ('in-memory, die with the server') is covered and partially compensates, but the return contract is a real gap for a session-creation tool.

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

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

Schema coverage is 0%, so the description must compensate and largely does: it defines both enum values of kind, explains seed as setting input cells (and names the graph-theory input cells), and explains capabilities as granting access to requiresCapability ops. The capabilities explanation is deferred to session_define's description rather than fully self-contained.

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 concrete verb and resource ('Open a reactive cell session') and then details what each kind produces, which lets an agent distinguish this from session_resume. It does not explicitly contrast itself with the sibling that resumes an existing session, so it stops short of a 5.

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

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

The description explains what 'generic' vs 'graph-theory' means and how seed/capabilities behave, which implicitly guides parameter choice. It never states when to call session_open instead of session_resume or session_list, so the when-to-use guidance 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?

With no annotations, the description carries the full burden and does so well: it discloses that resource guards (session/cell/payload limits) apply exactly as for session_open, and the critical gotcha that capabilities are NOT carried forward from the original session, defaulting to none unless passed explicitly. This is exactly the non-obvious behavior an agent needs.

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, then the behavioral caveats. Dense but every sentence earns its place except the minor '(issue #7)' aside. Slightly long for a two-parameter tool but no real 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?

No output schema exists, and the description does not state what a resumed session returns, but it thoroughly covers the behavioral risks. The main gap is the undocumented nested snapshot structure, which is not explained in either schema or description.

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 the optional 'capabilities' parameter semantics well ('pass this call's own optional capabilities to grant any, default none'), but the required nested 'snapshot' object (v, kind, free, defines) is described only as a 'session_snapshot document' with no field-level 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?

States a specific verb and resource ('Reconstruct a session from a session_snapshot document') and immediately differentiates it from session_open by clarifying the session is 'freshly opened, not re-authorized from wherever it paused.' An agent can distinguish it from session_snapshot (creates the doc) and session_open (starts fresh) without opening a 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?

Clearly establishes the context of use (given a session_snapshot document) and implicitly contrasts with session_open via the 'freshly opened' framing. It does not explicitly state when NOT to use it or name session_open as the alternative, so it stops short of full when/when-not guidance.

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

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

No annotations are provided, so the description carries full behavioral transparency. It discloses two important side effects: demotion of computed cells to plain inputs and lazy recomputation of dependent cells. This is solid, though it omits potential edge cases like whether the session must be open.

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, front-loaded with the main action and immediately followed by important behavioral details. Every sentence adds value with 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 covers the core action and key side effects, which is good for a simple setter. However, it omits sessionId semantics, the optional nature of value, and error/edge-case behavior, making it not fully complete for an unannotated tool without an 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?

With 0% schema description coverage, the description must explain all parameters, but it does not mention sessionId at all. It also says 'Set an input cell's value,' implying value is required, while the schema marks value as optional, creating ambiguity about whether a value must be provided.

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 primary action: 'Set an input cell's value (any JSON).' It also distinguishes the tool from siblings like session_get_cell and session_define by explicitly mentioning the behavior for computed cells, making the scope and effect unambiguous.

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

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

The description gives useful usage context by explaining that setting a previously-computed cell demotes it to a plain input and that dependents recompute lazily. It implies when the tool is appropriate, though it does not explicitly name alternative tools or exclusions.

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

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

With no annotations, the description carries the full burden and does well: it discloses that the computed-cell cache is deliberately omitted because cells re-derive from define() on resume, and that the output is a portable document usable in another process. It does not discuss side effects or failure modes, but for a serialize operation the key behavioral fact (what state is and isn't captured) is disclosed.

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 front-loaded sentences that each add substance: what is serialized, what is not, and how to consume it. The parenthetical '(issue #6)' is the one piece of noise that does not help an agent decide or invoke, slightly undercutting otherwise tight 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?

There is no output schema or annotation set, yet the description explains what the returned document contains and what the caller should do with it, which covers the important return-value concern. The only real gap is parameter origin/format for sessionId, which leaves the definition slightly short of fully self-contained.

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 sessionId parameter, so the description would need to compensate and largely does not — it never says where sessionId comes from (presumably session_open) or what form it takes. The session-centric framing implies the parameter's meaning, which is the minimum viable level given the coverage gap.

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

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

States a specific verb (serialize) and resource (a session's portable state), then enumerates exactly what is included (free-cell values, define-specs) and excluded (computed-cell cache). It also names the counterpart sibling session_resume, so an agent can distinguish it from session_get_cell or session_list without opening a 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?

Explicitly tells the agent what to do with the result: hand the document to session_resume, possibly across a different math-grapher process. That is a clear use context (session transfer/portability), though it does not state when NOT to use this tool or contrast with a sibling alternative beyond session_resume.

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