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

No annotations are provided, so the description carries the full load. "Read" and the pre-writing framing imply a side-effect-free retrieval, and "complete sample edition" hints that a substantial document comes back, but it does not state whether the content is static, large, or cacheable. With an output schema present, the return shape is covered elsewhere, so the remaining gap is modest.

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, with the content statement first and the call trigger second – well front-loaded and free of waste. It is arguably too clipped: the first sentence is a fragment with no verb, which costs a little immediate parseability.

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 zero-argument read tool with an output schema is a simple case, and the description plus the schema covers what an agent needs to decide to call it. The only absent piece is any sense of size or caching of the returned guide, which is a minor omission given the output schema exists.

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 about inputs to document; the baseline for a no-param tool is 4. Nothing in the description is needed to disambiguate arguments.

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 the resource precisely – layout rules plus a complete sample edition – which is specific enough that an agent knows what it gets back. It reads as a noun-phrase fragment rather than a verb+resource statement, and it does not explicitly contrast itself with the other siblings, but the pair of nouns is distinctive 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?

"Read before writing an edition" is an explicit, actionable precondition that tells the agent exactly when to call this. It gives no exclusions or mentions of alternatives, but for a prerequisite-reading tool the positive condition is the only one that matters.

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 it does disclose the content of the response (date, settings, edition state) so the agent knows it is a read. However, it doesn't confirm read-only safety, note any side effects, or clarify what 'their settings' includes, leaving behavioral details partly implicit.

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

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

Two short sentences, zero waste, with the payload described first and the imperative 'Call this first' front-loaded at the end as a clear call to action.

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 no-argument status tool with no annotations and no output schema, the description adequately tells the agent what comes back and why to call it early. The only gap is mild vagueness about the shape of 'their settings' and the edition status values.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a 0-param tool applies. No misleading parameter hints are present.

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 the resource (today's date, reader settings, edition readiness/printed state) concretely enough that an agent knows this is a status/orientation read rather than an action. It is distinguishable from siblings like save_settings or print_edition, though the verb is implied ('gives you') rather than stated as a specific 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?

'Call this first' gives explicit sequencing guidance that no sibling provides, which is genuinely useful for orienting an agent. It stops short of stating when not to call it or naming alternatives for narrower needs.

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 exist, so the description carries the full burden; it implies a safe read-only enumeration but never states that it has no side effects. It also omits what the result actually looks like (queue names, default marker), which matters since there is no output schema.

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

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

A single short sentence with no filler, and the resource scope is front-loaded immediately after the verb. Every clause adds information.

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, side-effect-free listing with no output schema, the description covers what is enumerated and the scope ("this computer"). Only a note on the returned shape or read-only nature would make it fully self-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 tool takes zero parameters, so the baseline is 4. There is nothing for the description to disambiguate and it correctly describes a no-argument call.

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

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

States a specific verb ("List") and resource ("print queues on this computer"), plus the added detail of returning the system default. It is clearly distinct from siblings like print_edition or print_test_page, though it never names them explicitly.

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

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

Usage is only implied: an agent can infer this is a discovery step before print_edition or print_test_page, but the description never says so or states any condition for calling it. No exclusions or alternatives are mentioned.

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 at all, the description carries the full disclosure burden and does well: it reveals that send=true causes exactly one physical print inside the reader's print window, and it explicitly warns against retrying on ambiguity, which signals non-idempotency — a critical trait an agent could not infer from the schema. It stops short of saying what happens on failure, how errors surface, or whether a printer must already be configured.

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

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

Three short sentences, no filler, with the dangerous mode (send=true) and its caution surfaced immediately after the baseline behavior. Every clause carries either a mode definition or a safety rule.

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-optional-boolean tool with no output schema, the description covers modes, side effects, and the retry hazard, and briefly indicates what the check returns ("shows the print command"). Gaps remain around preconditions (edition readiness, printer availability) and failure reporting, but they are modest for this complexity level.

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 define `send` — and it does, contrasting send=false (check only, show the print command) against send=true (print once). The default's consequence and the side effect of each value are fully spelled out, leaving nothing for the agent to guess.

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?

'Print today's ready edition' gives a specific verb and resource with a clear scope ("today's ready"), and the dry-run vs. real-print framing makes the effect unambiguous. It never names the nearest siblings (print_test_page, render_edition_pdf, publish_edition), so an agent must still infer which of these printing-adjacent tools to pick.

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 states precisely what each mode is for — send=false checks only, send=true prints — which is real when-to-use guidance for the only decision the caller makes. It also adds an operational rule ("never retry after an unclear result") but gives no routing guidance against the sibling tools or prerequisites such as a configured printer.

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 disclose a real behavioral gate: confirm=true plus a human go-ahead before anything is sent to hardware. It doesn't say what happens when confirm is false, what content is printed, or what result/error the caller sees.

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, zero waste, with the action front-loaded and the precondition second. Nothing to trim.

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 utility tool with no output schema, the description covers purpose, the confirmation requirement, and the human sign-off. Only the return/failure behavior is left unstated.

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

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

Schema coverage is 0% and the single parameter is only named 'confirm' with a false default, so the description does the compensating work by stating it must be true. It adds the non-obvious 'reader's go-ahead' precondition that no schema field conveys.

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 with scope: 'Print one test page to check the printer during setup.' The 'one test page' + 'during setup' framing implicitly separates it from print_edition and render_edition_pdf, though no sibling is named 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?

'during setup' gives clear context for when this applies, and the test-page framing delimits it from real jobs. It does not explicitly say when not to use it or name print_edition as the alternative for actual output.

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 burden. It hints at a review gate, but does not disclose what publishing actually does, whether it is reversible, what permissions are needed, or what side effects occur.

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, front-loaded with purpose and followed by the key constraint. There is no wasted 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 two-parameter mutation tool with no annotations and no output schema, the description is too thin. It omits parameter meanings, side effects, and return behavior, leaving the agent with significant 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 0%, so the description should compensate. It loosely implies the visually_reviewed requirement with 'looked at every page,' but never explains pdf_path or ties the boolean parameter explicitly to the review condition.

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 combination: 'Mark today's live edition ready for the morning print.' That distinguishes it from rendering or actual printing, though it does not explicitly name siblings like print_edition or render_edition_pdf.

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 gives a clear prerequisite: 'Only after you have looked at every page.' This tells the agent when the tool is appropriate, but it does not discuss alternatives 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?

With no annotations, the description carries the load and does disclose the key side effect: a non-live render is persisted as a proof that can never print, and output is one image per page. What it omits is whether the render mutates the edition object, whether proof storage is limited or costs anything, and any permission prerequisites.

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

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

Three short sentences, front-loaded with the action and output, then the dangerous parameter, then the recovery loop. Nothing is redundant and every sentence carries distinct information.

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?

Covers output shape and the live/proof semantics well for a tool with no annotations or output schema, but the required nested `edition` payload is left entirely undefined, which is the main thing an agent needs before calling. Adequate for the safety story, incomplete for the input 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 0%, so the description must compensate. It explains `live` well, including the default-false consequence, but the required `edition` parameter is a nested object with additionalProperties and gets no explanation of expected structure or required sub-fields anywhere.

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 ('Lay out an edition and return every page as an image'), plus the return format, which an agent can use to distinguish this from print_edition or publish_edition. It does not explicitly name the sibling alternatives, and the name says 'pdf' while the description promises page images, a minor mismatch left unexplained.

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 an explicit conditional for the risky path ('Set live=true only for today's real edition') and a follow-up workflow ('Fix any reported overflow by shortening copy, then render again'), which is genuine when-and-how guidance. It stops short of routing the agent between this and print_edition/publish_edition, so the sibling boundary 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. It usefully discloses a consent requirement and a key-validation rule, but leaves the most important mutation semantics unstated: whether omitted settings are preserved (partial merge) or reset, and what happens on an invalid key (error vs. silently ignored).

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, no filler. The key enumeration is compact and the consent instruction is placed last as a hard stop before acting.

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 or annotations exist, so the description must cover purpose, valid inputs, and safety, and it largely does. The remaining gap is mutation semantics — partial vs. full update and error behavior for rejected keys — which matters for a nested free-form object.

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% and the single parameter is a free-form object with additionalProperties:true, so the schema alone tells an agent nothing. The description compensates by enumerating the 13 accepted keys, which is exactly the meaning an agent needs; it stops short of giving types or formats for those keys.

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 ("Update the reader's settings") plus the exact accepted key set, which immediately distinguishes it from neighbors like save_sources and get_layout_guide. It does not explicitly name a sibling as an alternative, but the resource is unambiguous.

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

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

"Ask the reader before changing anything" gives a real precondition for invoking, and "Only known keys are accepted" bounds the input. However, there is no guidance on when to use this versus save_sources or the print tools, and no statement about what to do when a key is unknown.

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 disclosure burden, and it does deliver one genuinely important behavior: 'Store summaries only, never message bodies, codes or passwords' — a hard privacy constraint an agent could not infer elsewhere. It leaves the core write semantics unstated, though: whether a second call overwrites or appends to today's record, and whether the operation is idempotent.

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, zero filler. The scope statement comes first and the safety constraint follows immediately, both earning their 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 tool is low-complexity (one parameter) and an output schema exists, so return values need no explanation; the privacy directive covers the highest-risk aspect. The remaining omission is overwrite/merge semantics for a write tool with no annotations 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% and the single 'record' parameter is a free-form object with additionalProperties: true, so the description must define the payload — and it does, enumerating the content categories (URLs, checked times, window, inboxes, calendars, failures). It falls short of giving key names or types, leaving the agent to infer the object shape.

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 pairs the specific verb 'save' with a concrete resource ('today's source record') and enumerates its contents (story URLs, checked times, collection window, inboxes/calendars read, failures), which is far more informative than the bare name. It doesn't explicitly contrast itself with siblings like save_settings or journal_status, but the domain is clearly distinct enough to identify on sight.

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 'today's source record' implies a daily, post-collection save, but there is no explicit statement of when to call it, whether it must precede other edition-building steps, or what to do instead. Usage is implied rather than prescribed.

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