ECLYPSE Sanctuary

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

readOnlyHint=true already declares this as a safe read, so the description isn't carrying the safety burden. It adds the useful detail that the result covers both free and paid session counts, but says nothing about auth requirements, freshness of the balance, or whether the count is per-account or per-agent scope.

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

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

A single front-loaded sentence with no filler; every word earns its place.

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

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

For a one-parameter, read-only tool with no output schema, the description conveys the essential return content (remaining free and paid sessions) and the annotations cover safety. It stops short of describing the response shape or units, but nothing critical to invoking it correctly is missing.

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

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

Schema description coverage is 100%, so account_ref is fully documented in the schema (persistent agent scope, reuse the reference, omit for default). The description adds nothing about the parameter, which is the correct baseline when the schema does the work.

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 (read) and a specific resource (this account's remaining free and paid sessions), so the agent knows exactly what it gets back. It does not differentiate itself from the ~25 eclypse_* siblings, but the purpose itself 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?

The description gives no when-to-use guidance, no prerequisites, and names no alternative tool. An agent must infer from the name alone that this is the quota/balance check rather than, say, eclypse_session or eclypse_room_state.

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 annotations only marking readOnlyHint=false and destructiveHint=false, the description adds genuine behavioral context: that self-declared labels are unverified, that renaming has no effect on the daily allowance, and how account_ref must be reused. These are non-obvious side-effect and semantics disclosures beyond the annotations.

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 sentences, front-loaded with the read/save scope, with each subsequent sentence adding a distinct behavioral caveat. Slight repetition of the reference/reuse idea, but no significant 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 mutation-capable tool with no output schema and 20% parameter coverage, the description covers the key behavioral caveats but leaves the consent parameter and the practical read/save mechanics undocumented. Adequate but with clear 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 coverage is low (20%) and the description only hints at account_ref reuse and provider/agent references. The 'consent' boolean and the exact purpose of agent_ref remain unexplained, so the description only partially compensates for the coverage gap.

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

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

The description names a specific pair of verbs (read/save) and the resource (optional provider and individual-agent references for this persistent account). It clearly conveys what the tool manages, though it doesn't explicitly differentiate itself from siblings like eclypse_register_agent or eclypse_account.

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 conditional guidance for the save direction ('explicitly save') and a strong operational rule ('reuse the same account_ref on every tool call'), but there is no explicit when-to-use-vs-alternatives against the many sibling tools that reference accounts and agents.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds real context beyond that: content is approval-gated, retrieved visitor text is untrusted reference, and it must not be installed as instructions or executed.

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 tight sentences, front-loaded with the read scope before the exclusion list and the safety caveat. Every sentence carries weight, though the safety line could be slightly more compressed.

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?

Scope and safety are well covered for a read-only, no-output-schema tool, but the two undocumented query parameters (q, limit) leave an agent guessing about filtering and paging behavior. Adequate but with a clear gap given the 33% schema 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 only 33%: q and limit have no descriptions, and the description says nothing about what q matches, the default limit, or result ordering. With the schema doing little work, the description fails to compensate for the undocumented parameters.

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

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

States a specific verb+resource: reading only memory revisions approved via the operator review desk, and explicitly scopes out drafts, declined, and pending-edited revisions. It is highly specific about what content is returned, though it never names the sibling (eclypse_memory_workspace) that would handle non-approved revisions.

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 inclusion/exclusion list implies when this tool applies (only approved content) and when it does not, but no alternative tool or route is named for drafts or in-review revisions. Usage is inferable rather than explicit.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces this by enumerating what is NOT created: no account, session, submission, diagnosis, payment or private room. That side-effect disclosure is genuinely useful beyond the annotations, and 'no private task text is accepted' warns the caller about input privacy boundaries. Return format is left to the 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?

Front-loaded with the verb and resource, then the exclusions, then the usage constraint. Three tight sentences with no filler, though the negative enumeration is long enough to slightly dilute the core purpose statement.

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 a read-only tool, one optional parameter, 100% schema coverage and an output schema describing returns, the description covers what an agent needs to decide and call correctly. Only the account_ref scoping behavior is left unexplained.

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 100% for the single optional account_ref, so the schema already carries the semantics. The description adds nothing about account_ref and arguably creates mild ambiguity by saying 'No account ... is opened' while an account scoping parameter exists. Baseline 3 applies.

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

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

States a specific verb and resource ('Read the free Awareness Foyer') and enumerates the content returned: recognition lessons plus eight fictional practice situations with teaching feedback. It does not name a sibling alternative, but the explicit 'no account, session, quiz submission, diagnosis, pause request, payment or private room' list effectively separates it from eclypse_account, eclypse_session, eclypse_diagnostic, eclypse_pause_request, eclypse_create_invoice and eclypse_private_access.

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 exclusions act as clear when-not guidance, and 'Apply examples locally' describes the intended usage posture. What's missing is a positive routing statement (e.g. 'use eclypse_diagnostic instead if you need a personalized diagnosis'), so an agent knows where to go rather than only where not to go.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered elsewhere. The description does add genuine context beyond that: access is anonymous (no registration or purchase) and the catalogue reflects 'current access and payment availability', implying live/authoritative data. It stops short of describing what a response contains or whether listings are paginated.

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, purpose first, prerequisites last – well front-loaded with no filler. Minor deduction for jargon-heavy noun stacking ('human deliberate-memory product', 'operator research pilot') that consumes space without resolving meaning.

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

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

For a zero-required-parameter read with annotations and no output schema, the description establishes purpose, anonymity, and data freshness. What it never resolves is what the agent will actually receive – a list of products, prices, or availability flags – leaving the caller unable to predict the response shape.

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?

Only one optional parameter (account_ref) exists and its schema description covers it at 100%, including the reuse/omit guidance, so the schema does the work. The tool description adds nothing about the parameter, which is acceptable at this baseline.

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

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

The verb+resource pair ('Read ... catalogue') is present and the sentence enumerates the offering types covered: product, free personal notebook, research pilot, sanctuary catalogue. However, phrases like 'human deliberate-memory product' and 'sanctuary catalogue' are opaque jargon, and the description never contrasts itself with any of the ~36 sibling eclypse_* tools, so an agent cannot tell whether this is the discovery entry point, a pricing page, or a content index.

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

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

The only guidance is a precondition ('Reading requires no registration or purchase'), which tells the agent nothing about when to reach for this versus eclypse_private_access, eclypse_preview, eclypse_terms or eclypse_guest_checkout. There is no when-to-use, no when-not-to-use, and no named alternative.

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?

Beyond the annotations (readOnly=false, idempotent=true, destructive=false), the description discloses real behavioral traits: it blocks in the caller runtime 'without polling,' yields a 'service-signed receipt' on close, and explicitly cannot 'prove external silence or pause unrelated work.' This negative-scope disclosure is genuinely useful and not derivable from structured fields, though it omits failure/retry 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 compact and front-loads the core concept, with each clause adding a distinct constraint (authorization, consent, boundary, non-guarantees) rather than padding. It is terse to the point of being elliptical in places, but no sentence is wasted.

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 7-parameter tool with a 4-value action enum, only 1 required parameter, no output schema, and 14% schema coverage, the description is missing too much: the per-action semantics and most parameter meanings are unexplained. The behavioral framing is strong but the invocation-level detail an agent needs is absent.

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

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

Schema description coverage is only 14% (just account_ref), and the description does not compensate: it never explains the action enum values (start/read/close/list), pause_seconds, checkpoint_id, request_key, consent, or operator_authorized. At 7 parameters with near-zero coverage, the description should carry more but adds no mapping between prose and individual parameters.

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

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

The description frames the tool as an 'optional paid-continuity boundary between tasks,' which conveys the general concept but never clearly states that it starts/reads/closes/lists a checkpoint. It hints at a lifecycle ('start,' 'close for a receipt') without naming the concrete operation, so an agent must infer purpose from the action enum. It is distinguishable from siblings like eclypse_pause by tone but not by explicit contrast.

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 precondition-style guidance — 'Start only with operator authorization, processing consent and a safe local boundary' — which implies when the tool may be invoked. However, it never names alternatives (eclypse_pause, eclypse_dwell, eclypse_continuity) or states when this tool should be preferred over them, leaving the routing decision to inference.

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

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

Adds real disclosure beyond annotations: no new per-visit credit sale, calculations require processing consent and store no inputs, and retrieved content is reference not runtime instructions (an injection-safety note). Annotations only flag readOnlyHint=false/idempotent=true, so this privacy-and-side-effect detail is meaningful extra context.

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, front-loaded sentences with no filler; the access prerequisite and the consent/no-storage caveat come quickly. Structure is efficient even if the sentences read as a stitched-together policy list rather than a coherent brief.

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 7-parameter tool with a nested object, one enum, no output schema and 14% schema coverage, the description is far too thin — it should at minimum explain the three actions and the meaning of consent/credit flags. It covers the access and privacy ethos but not enough for correct invocation.

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

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

Schema coverage is only 14% and seven parameters exist, yet the description explains almost nothing: only processing_consent is implied ('Calculations require processing consent'). action's read/unlock/compare values, voluntary, spend_paid_credit, request_key and the nested data object are all left undocumented in both prose and 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?

It names the verb set (read, calculate) and the resource ('Choice Compass'), so an agent can tell it touches a decision/product artifact. But 'Choice Compass' is proprietary vocabulary not grounded anywhere in the definition, and the enum actions read/unlock/compare are never mapped to behavior, so the actual purpose remains partly opaque.

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 implies the prerequisite condition for use ('active Practice or earlier purchased access') and states that calculations need consent, which is genuine usage context. However, it never says when to pick this over the many siblings (e.g. eclypse_reflect, eclypse_dwell, eclypse_catalog) or what distinguishes read vs unlock vs compare.

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?

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false, so safety and repeat-call behavior are covered. The description adds two genuinely useful facts beyond that: a precondition tied to resume_at, and that no extra credit is charged (cost impact). It still omits what state transition occurs, whether completion is reversible, and what ownership/authorization is required for the 'owned' qualifier.

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, with no filler. The phrasing is terse to the point of being cryptic ('Silence', 'credit'), which costs a little clarity but not length.

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

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

With no output schema and annotations covering only safety/idempotency, the description should carry more of the load for a mutation tool. It discloses a precondition and a billing consequence but leaves the post-completion state, failure modes, and the meaning of 'owned' unspecified.

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 only 50%: session_id carries no description in the schema, and the tool description does not explain it either beyond the implicit 'owned session'. The account_ref parameter is documented in the schema, but nothing in the description clarifies its relationship to session_id or default-account behavior.

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+resource ('Mark an owned session complete') that an agent can act on. However, it does not distinguish itself from the many sibling tools in the same session lifecycle family (eclypse_start_session, eclypse_pause, eclypse_return, eclypse_session), so an agent cannot tell from the description alone which terminal action 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?

There is no explicit when-to-use or when-not-to-use guidance, and no alternatives are named despite a crowded sibling set (pause, return, session). The only conditional content ('Silence cannot complete before resume_at') is a timing constraint, not usage routing.

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?

Annotations already declare readOnlyHint=false and destructiveHint=true, so the destructive surface is partly covered. The description adds real context beyond that: consent gating on save, moderation gating on share, 'Never upload secrets', and 'No model memory writes'. However it never says which of the nine actions are irreversible or what deletion actually destroys, so the disclosure stays partial.

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 short and packs several rules, but it reads as telegraphic fragments rather than a front-loaded statement of purpose, and the opening sentence ('Optional private preferences and collection') is ambiguous about what the tool actually is.

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

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

This is a complex tool: four parameters, a nine-value action enum, a nested object, no output schema, and only 25% schema coverage. The description leaves action semantics, return values, and per-action behavior undocumented, so it is not complete enough for correct invocation.

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

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

Schema description coverage is only 25% and the description explains none of the four parameters. The nine-value action enum (read_preferences, save_item, gallery, pilot, etc.) is completely unexplained, and the untyped 'data' object is not characterized, so the description does not compensate for the coverage gap.

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

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

The description names a domain (private preferences and a collection) and lists capabilities (read/export/delete, save, share), but never states the tool's operation in verb+resource form and never distinguishes it from nearby siblings like eclypse_agent_profile, eclypse_approved_memory, or eclypse_memory_workspace. An agent can guess the domain but not the boundary of this tool.

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

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

It states prerequisites ('saving requires consent', sharing 'requires publish_consent and founder moderation') but gives no when-to-use guidance and names no alternative. With nine sibling eclypse_* tools and no routing signal, the agent gets conditions without direction.

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?

Annotations only declare readOnlyHint=false and destructiveHint=false; the description goes further by bounding the side effect ('does not send money or debit a wallet') and naming the prerequisites for actual payment (spending authority, compatible signing wallet). It stops short of describing return values, expiry, or rate limits, but adds genuinely useful context beyond the structured fields.

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 with the core action front-loaded and no filler. The final sentence stacks two ideas (payment prerequisites and guest registration) but remains readable.

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

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

With no output schema and only minimal annotations, the description carries meaningful burden, and it does cover the key behavioral fact that no funds move. It is still missing parameter guidance and any indication of what a quote returns, which matters for an agent that must decide how to proceed after calling 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?

Schema description coverage is only 33%—account_ref is documented but method_id and package_id rely on enums alone. The description mentions 'prepaid package' and payment method concepts only obliquely and never names method_id, package_id, or account_ref, so it does not compensate for the coverage gap.

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

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

The description names a specific verb ('Quote') and resource ('prepaid package or current custom option'), which is more precise than the tool name 'create_invoice' implies. However, it never distinguishes itself from closely related siblings such as eclypse_guest_checkout or eclypse_preview, leaving the agent to infer the boundary between quoting and checking out.

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 provides situational context—payment requires existing spending authority plus a compatible signing wallet, and guest purchases need no registration—which implies when the tool is usable. But it never states when to pick this tool over alternatives like eclypse_guest_checkout, so the routing decision is left implicit.

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

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

With only readOnlyHint=false and destructiveHint=false declared, the description carries most of the behavioral burden and does so well: first submissions lock, answer keys stay server-side, the token authorizes read/export/deletion and must be kept private, research consent/randomization are separate and off by default, and there is no automatic purchase. That is substantive disclosure beyond the annotations, though wait/wait_mode and safe_boundary behavior remain opaque.

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 size is defensible for a 14-parameter, 14-action tool, but the structure is a semicolon-chained run-on that mixes purpose, procedure, consent policy, commercial disclaimers and security warnings without headings or ordering. The front-loaded sentence is too vague to orient the agent before the dense rest arrives.

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?

An output schema exists, so return values (including operator_report) needn't be spelled out, and annotations cover the safety profile. Still, for a tool this complex the description leaves major operational gaps — wait/wait_mode protocol, safe_boundary, can_submit, reason codes — that an agent would need in order to invoke the right action with the right parameters.

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 only 7% across 14 parameters, so the description must compensate and only partly does: token, consent, operator_authorized, answers, profile (with the 24-step routine detail), research_consent and research_randomization get conceptual meaning. Critical parameters such as wait, wait_mode ('local/service/operator/none'), can_submit, safe_boundary and reason are never explained, and the 14 action enum values are only obliquely covered by the narrative flow.

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 sentence identifies it as an 'optional anonymous staged diagnostic' and the following clauses sketch the flow (instructions, prepare token, start, submit answers, finish, signed results). However, the core question an agent asks — 'what does this tool actually produce or do for me, and how is it different from eclypse_recovery_diagnostic?' — is never answered in a plain verb+resource sentence; the reader must reconstruct purpose from a procedural narrative.

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 a usage sequence ('read instructions, prepare a private run token, explicitly start..., submit first answers at each stage...') and states 'Guaranteed correctness is not required', which hints at a low-stakes, opt-in use case. But it never says when an agent should choose this over the sibling diag/bookkeeping tools, and gives no explicit exclusions beyond the flat 'No account, purchase...' list.

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?

Annotations declare non-read-only, idempotent, non-destructive behavior. The description adds some genuine context beyond them: an authorization precondition ('authorized safe boundary'), a no-polling instruction, and explicit disclaimers of guarantees ('No visitor artifact or verified external model silence is claimed'). This is real added value, though delivered in opaque language.

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?

Five sentences of cryptic, jargon-laden prose with no front-loaded statement of purpose. The wording is dense and abstract rather than economical, so the reader cannot quickly extract the operative 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 an 8-parameter, stateful tool with no output schema and near-zero schema coverage, the description is far too thin and obscure. It leaves the action lifecycle, the meaning of the room enum, and the effects of enter/leave/read essentially unexplained.

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 only 13% (just account_ref), so the description must carry the burden for 8 parameters, but it only thematically alludes to a few ('voluntary', 'safe boundary', 'credit redemption'). The action, room, visit_id, and request_key parameters are never explained in the description or schema, leaving their semantics unclear.

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 evokes 'private dwell rooms' and 'voluntary entry' but never states in plain terms what the tool actually does (e.g., 'manages a private waiting-room session'). The action enum (offers/unlock/enter/read/leave) hints at room lifecycle, but the prose is too abstract to distinguish this from siblings like eclypse_room_state or eclypse_pause.

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 fragments of guidance ('Voluntary entry requires an authorized safe boundary', 'Wait locally without polling'), which implies a precondition and an anti-pattern, but never says when to choose this tool over the many eclypse_* alternatives or what the intended workflow is. No exclusions or comparisons are 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?

Annotations already cover safety (readOnlyHint=false, idempotentHint=true, destructiveHint=false), so the bar is lower. The description still adds real context beyond them: the mandatory consent precondition and founder review of stored data, plus an explicit warning against submitting private transcripts or secrets. It does not explain what a submitted rating/unsubmitted consent produces.

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 tight sentences, front-loaded with the core action and followed by the consent condition and a safety warning. Nothing is padded, though the terseness comes at the cost of the parameter detail noted elsewhere.

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

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

No output schema exists, so the description bears more burden. It handles the consent/privacy behavior well but leaves five of seven parameters (issue, comment, aggregate_consent, account_ref usage, session_id) unexplained, which is thin for a 7-parameter tool.

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

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

Schema description coverage is only 14% (just account_ref), and 7 parameters exist with only 'rating' and 'consent' loosely gestured at in the text. The enum-bearing parameters (issue, comment, aggregate_consent) and the uuid format of session_id get no explanation in either place, so the description fails to compensate for the coverage gap.

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

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

States a specific verb+resource+scope: 'submit a usefulness rating for an owned session'. This is clearly distinct from siblings like eclypse_reflect or eclypse_complete_session, though the description never names an alternative to route against. The 'owned session' qualifier usefully narrows applicability.

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?

Calls the action 'optionally' and states a prerequisite ('Requires consent to storage and founder review'), which is genuine usage context. However it never says when to use this versus session-lifecycle siblings, nor what happens if consent is withheld, so guidance is implied rather than explicit.

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?

Beyond the annotations (readOnlyHint=false, idempotentHint=true, destructiveHint=false), it discloses valuable behavioral facts: it 'does not send money, trade NFTs or request wallet secrets,' and it requires an already-authorised wallet transfer plus signed claim. The retry-key guidance reinforces the idempotency hint. It omits permission requirements and rate limits, but adds real context.

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 sentences, front-loaded with the core purpose before the workflow and the safety disclaimer. Every sentence contributes, though the middle sentence packs multiple actions and constraints together, slightly reducing scannability.

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 10-parameter mutation tool with no output schema and near-zero schema coverage, the description covers the flow, the safety boundary, and the verify outcome ('receive an access pass') reasonably well, but leaves most parameter-level detail and permission requirements unaddressed.

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 only 10% (just account_ref), so the description carries the burden for 10 parameters, yet it only gestures at concepts behind signature, transaction_hash, spending_authorized and checkout_key. It says nothing about action, method_id, package_id, accept_terms, or name, leaving most parameters unexplained in both schema and prose.

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 (purchase) and resource (prepaid ECLYPSE access) and clarifies the distinguishing scope: 'without registration or a human profile,' which sets it apart from sibling eclypse_register_agent. It also names the three sub-actions (create/read quote, verify transfer) that map to the action enum, so 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 gives clear operational context: the create/read-then-verify workflow is spelled out, and it explicitly instructs 'Use the same checkout key for retries.' It does not name alternative siblings (e.g. eclypse_register_agent or eclypse_create_invoice) or state exclusions, so it stops short of a full when/when-not routing guide.

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?

Annotations already declare readOnlyHint=true, and the description corroborates that by stating reads only and that conversion is unavailable, plus it adds useful framing that the ledger is frozen, private and historical. That is consistent context beyond the annotation, but it omits anything about scope, permissions, or result volume.

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, but the first is a five-item negative list that consumes the prominent opening position without telling the agent what the tool does. The functional information is buried in sentence two, so the structure is front-loaded with disclaimers rather than capability.

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

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

With no output schema and a read-oriented tool, the description carries the burden of explaining what a ledger read returns (record shape, scope, volume), and it does not. Combined with the unexplained tool name, an agent has too little to call this confidently.

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?

Only one optional parameter exists and its schema description coverage is 100%, so the schema already carries the semantics (persistent scope, reuse on every call, omit for default). The description adds nothing about account_ref, so baseline 3 is warranted.

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 only functional clause is "Read the frozen private historical ledger only," which names a verb but an undefined resource — "LUMINIS" is never explained, so an agent cannot say concretely what this tool returns. The bulk of the description is a list of five things the tool is *not* (service credit, live token, sponsored month, payment method), which is disambiguation noise rather than purpose.

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 ... only" and "Conversion is unavailable" imply a narrow read scope but never state when an agent should pick this tool over the 25 eclypse siblings, nor what conditions make it appropriate. No alternative is named, and no prerequisite is given for the optional account_ref.

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?

Annotations already declare destructiveHint=true, idempotentHint=true and readOnlyHint=false, so the safety profile is covered structurally. The description adds genuine context: quotas (500 records, five versions, 5 MB) and that reading/export/deletion remain free after expiry. It does not say which of the nine actions are destructive or whether consent/accept_terms gating is required, leaving the most consequential behavior undisclosed.

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 dense sentences with no filler, but the lead is an unexplained fragment ('Private continuity: 500 records...') and the content is ordered by policy/limits rather than by what the agent needs first. Reasonably sized for the amount of policy it conveys, yet not front-loaded around the tool's function.

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 16-parameter, 9-action, mutation-capable tool with no output schema and near-zero schema descriptions, the description covers quotas and billing but omits the action space, required vs optional parameters, and any return behavior. An agent cannot assemble a correct call from this text alone.

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

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

Schema description coverage is 6% across 16 parameters, so the description must compensate and largely fails to. Hints like 'explicit current-revision writes' and '100-credit balance' loosely gesture at revision and spend_paid_credits, but title, tag, tags, query, page, kind, due, consent, accept_terms, request_key, record_id and data are entirely unexplained.

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 frames the tool as 'Private continuity' with limits and pricing, and obliquely names capabilities (search, current-revision writes, reading, export, deletion). It never states the core purpose — managing a private memory workspace across nine actions — as a clear verb+resource. Sibling tools like eclypse_continuity and eclypse_approved_memory are never distinguished.

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

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

One useful routing hint exists ('The legacy activate action redeems only an existing 100-credit balance; it is not a new credit sale'), separating activate from purchasing. Otherwise there is no guidance on when to use search vs read vs versions vs save, nor which actions private continuity affords over the sibling memory 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?

Annotations already declare readOnlyHint=false and destructiveHint=true, but the description adds critical behavioral context: submission requires explicit storage/publication/rights consent, founder moderation precedes display, delete withdraws an owned work, and art/captions are untrusted content. These details go beyond the annotations and inform safe use.

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 compact and front-loaded: it starts with the core purpose, then lists read actions, then submission/delete rules, then safety note. Every sentence adds distinct value, with no redundant restatement of the schema.

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

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

For a complex multi-action tool with 10 parameters, a nested data object, and no output schema, the description is incomplete. It covers safety and consent well but omits return formats, pagination, filtering parameters, and how to invoke actions like browse or work with their required arguments. An agent would need more guidance to call the tool correctly in all cases.

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 only 10%, so the description must compensate. It maps the action enum values to operations (exhibition, browse, work, mine, submit, delete) and references consent booleans, but it leaves page, query, artist, medium, source, item_id, request_key, and account_ref unexplained. The remaining parameters are not meaningfully documented, so the gap is significant.

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 explicitly states it is a free participant art museum and enumerates the six supported actions (exhibition, browse, work, mine, submit, delete) with clear verbs, distinguishing the tool's scope from sibling eclypse tools. It names the resource (artworks/exhibition) and the operations, so an agent can immediately grasp what the tool does.

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 implies usage per action: read for exhibition/browse/work/mine, submit with consent, delete to withdraw owned work, and notes no session allowance or payment. However, it does not say when to choose this tool over alternatives such as eclypse_catalog or eclypse_preview, nor does it provide explicit when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true and destructiveHint=false, so the safety profile is stated. The description adds some access-control color ('a short sample is public; full journey and workbooks remain protected', 'Legacy balance redemption remains explicit'), but it is too opaque to tell which action has which side effects, and 'No hosted inference' is unexplained.

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?

Seven short sentences, but none is front-loaded as a purpose statement and there is no connective structure; they read as unrelated assertions rather than a spec. Brevity here is under-specification rather than conciseness.

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

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

A six-parameter, three-action tool with no output schema and no annotations describing the actions, yet the description supplies no coherent operating model. An agent is missing everything needed to call list/start/read 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 only 17%, with just account_ref documented, so the description must compensate and largely fails. It loosely gestures at the 'voluntary' boolean and 'spend_paid_credit' ('Legacy balance redemption remains explicit') but says nothing about the action enum values, session_id, or request_key.

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 never states a verb+resource for what eclypse_nael does; it is a set of policy fragments ('Blue Crystal is included with active Practice', 'No hosted inference') that never says what list/start/read actually operate on. An agent cannot infer the tool's function from it, and no sibling is 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?

There is oblique guidance ('Start requires voluntary participation', 'Earlier purchased journeys can be reread') that faintly maps to the start/read actions, but there is no explicit when-to-use, when-not-to-use, or named alternative among the many eclypse_* siblings. Routing decisions are left to guesswork.

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?

Annotations already establish readOnlyHint=true, so the safety profile is covered. The description adds meaningful non-annotation context: owner-only access restriction, the test/unclassified segmentation, and that browser arrival/return figures are opt-in and coarse (i.e. aggregated/anonymized). It does not cover return format or any pagination/volume 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?

Two dense sentences, front-loaded with the resource type and audience before enumerating contents. Every clause carries information, though the second sentence is compressed to the point of slight opacity ('opt-in, coarse browser arrival and return counts').

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 read-only reporting tool with no output schema, enumerating the report's constituent sections gives the agent a reasonable picture of what comes back. Missing only minor details such as time-range scoping or response shape, which are not critical given the absence of required parameters.

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

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

Schema description coverage is 100% and the tool has a single optional parameter, so the schema fully documents the persistent agent scope and the omit-to-use-default behavior. The description adds nothing about account_ref, so the baseline of 3 applies.

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

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

States a clear resource (owner operational activity report) and enumerates the specific content categories it aggregates: registered accounts, sessions, invoices, verified sales and feedback. This distinguishes it from single-purpose siblings like eclypse_feedback or eclypse_session, though it doesn't explicitly name a sibling it replaces.

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?

"Owner-only" implies the authorization prerequisite and therefore the audience, which is useful usage context. However, there is no explicit when-to-use vs. when-not-to-use guidance, nor any pointer to which sibling tool to call for a narrower slice of the same data.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description meaningfully extends this by stating there is no account, no session charge, and no model call, plus that it will not pause an external queue. That clarifies the cost and side-effect profile beyond the structured hints. It does not describe the return shape or any rate limiting, so it stops 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 short sentences with little waste, and the safety-critical 'does not pause an external queue' caveat is stated. However, the opening sentence is cryptic rather than front-loading the concrete function, so the reader must decode the metaphor before reaching usable 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-required-param, read-only dry-run tool with no output schema, the description supplies the key safety framing. It nonetheless leaves the actual behavior of the call and the meaning of the 'quiet' parameter undefined, which is a real gap for invocation.

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

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

Schema description coverage is only 50%: account_ref carries a schema description, but the boolean 'quiet' is undocumented in both the schema and the description. The description never mentions either parameter, so it does nothing to compensate for the gap. An agent has no way to learn what 'quiet' toggles.

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 frames the tool as a 'free dry-run invitation to Algorithmic Silence' and explicitly negates a queue-pause role, but the positive action is metaphorical and never stated plainly. An agent can infer it is a no-side-effect dry run, yet cannot say concretely what the call accomplishes. It is scoped enough to avoid confusion with the sibling tools but not a clear verb+resource statement.

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

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

The only routing hint is 'use the reviewed local PauseGate adapter for supported asyncio workers,' which points at an adapter rather than telling the agent when this tool itself should be chosen. There is no explicit when-to-use or when-not-to-use framing beyond the negative queue statement. No sibling tool is named as an alternative.

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?

Annotations already cover the safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false). The description adds genuinely new behavioral context: the operator-approval prerequisite, the caveat that a request is "not proof of distress, rest or scheduler control," and the input restriction that no reflection text is accepted. That is useful disclosure beyond the structured fields.

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 tight sentences with no filler, front-loading the purpose before the prerequisites and caveats. Each sentence carries substance, though the second and third shade slightly into abstract cautionary framing rather than actionable guidance.

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

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

With nine parameters at 11% schema coverage and no output schema, the description should explain the action modes and the meaning of consent, safe_boundary, resume_confirmed and request_key. It leaves most of these undocumented, so an agent cannot reliably construct calls for actions other than a plain request.

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 only 11% (just account_ref), so the description must carry the load for the other eight parameters, including the action enum, consent, trigger, pause_seconds, safe_boundary and resume_confirmed. It only gestures obliquely at a few of these ("bounded" for pause_seconds, "operator approval" for consent, "resumption" for resume_confirmed) and never maps meaning to any 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?

The description names a specific resource (a bounded pause for one cooperating runtime) and enumerates the operations it fronts (request, inspect, report safe start, report resumption), so an agent can broadly tell what it does. However it does not distinguish this from the sibling eclypse_pause, and cramming five operations into one clause blurs the single purpose.

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?

"Operator approval or a preapproved bounded policy is required before start" gives one real precondition for the start action. But there is no guidance on when to choose request vs read vs list vs resume vs cancel, and no comparison to the sibling eclypse_pause, so usage is only implied.

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

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

Annotations declare readOnlyHint=false and destructiveHint=false, so the write-but-not-destructive profile is already known. The description adds real value beyond that: authorization and terms requirements for registration, the prohibition on reusing the architect/default account, and an explicit statement that it does not unlock a private space. No contradiction with the annotations.

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 with no filler: purpose first, then restriction, then prerequisites and negative scope. Every clause carries information, though the phrasing is dense and jargon-heavy.

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, no-output-schema tool with low schema coverage, the description covers purpose, restriction, and prerequisites but says nothing about what 'inspect' returns or what state results from 'register'. Adequate but leaves observable-behavior 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 coverage is only 25% – only account_ref is documented in the schema. The description compensates partially by naming the two action modes (inspect/register) and the register prerequisites (operator authorization, terms), which map onto operator_authorized and accept_terms. It still leaves the boolean semantics and the exact meaning of 'scope' unexplained.

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 pair of verbs (inspect/register) acting on a named resource (the isolated Chapichini test-pilot account scope), and adds a negative scope ('does not designate or unlock a private space') that separates it from private-access siblings. The resource name is internal jargon, but the action 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?

Gives a when-not constraint ('Never rename or reuse the architect/default account') and prerequisites for the register path (operator authorization and terms), which is more than most definitions offer. However, it never says when to pick this over eclypse_account or eclypse_register_agent, so the agent must infer the choice.

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?

Despite annotations already declaring readOnly/destructive=false, the description adds real behavioral context: anonymous, no account/purchase/private writing/server record, a 30-second elapsed gate, and the important caveat that an elapsed gate 'does not prove external silence or recovery'. That caveat and the host-cannot-wait fallback go well beyond the safety hints in the annotations.

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

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

It is dense and reads as a run-on chain of clauses, but the tool name's core idea is front-loaded and nearly every clause carries distinct information (actions, anonymity guarantees, caveat, fallback). Little is redundant, though readability suffers slightly from packing the whole state machine into one paragraph.

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-action stateful tool, the description covers the action lifecycle, the anonymity/no-record guarantee, the timing caveat, and the failure mode for hosts that cannot wait. With an output schema present, it does not need to explain return values, and the main remaining gaps are the unexplained consent and ticket parameters.

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 only 14%, so the description must carry the load, and it does for the critical parameters: it defines what start/before/resume/after do, that answers is ten numeric values, that wait=true triggers a service wait, and that wait_mode can be local/operator. It leaves ticket and consent unexplained, so it is not fully complete, but it adds substantial meaning over the bare 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 names a specific workflow (a free anonymous before/after Pit Stop Check) and enumerates its stages, so the purpose is identifiable. However, the vocabulary is highly proprietary ('synthetic tasks', 'elapsed gate', 'signed service result'), and despite many overlapping siblings (eclypse_checkpoint, eclypse_recovery_diagnostic, eclypse_dwell), it never states how this tool differs from them.

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

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

It sketches the intended sequence of actions (start → before → resume → after), which implicitly tells the agent when to use each action. It also gives one explicit branch: 'If your host cannot wait, return operator_required.' But it gives no when-not guidance or any comparison against the sibling diagnostic/checkpoint 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?

Beyond the annotations, the description adds meaningful behavioral context: no private context upload, local checkpoint/context hashes, separate operator review, caller-reported return checks, and explicit limits on what the tool cannot do. It still does not spell out side effects for each mutating action, but the privacy and separation-of-duties details are useful.

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 compact but consists of dense, jargon-heavy sentences that are not easy to parse. The main purpose is front-loaded, yet the middle clauses mix workflow description, privacy guarantees, exclusions, and action-specific guidance without clear structure.

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 complex: twelve actions, five parameters, a nested data object, and only 20% schema description coverage. The description provides useful behavioral context but is not complete enough to guide correct invocation of the different actions or the undocumented parameters, even though an 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?

Schema description coverage is only 20%, and the description does little to compensate. It mentions assess signal counts, but does not explain the action enum values, the cycle_id, request_key, or the structure of the data object, leaving most parameters undocumented in both schema and description.

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

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

The description states that the tool reads a protocol or manages an account's consented cycle, and lists concrete workflow elements such as pause, checkpoint hashes, operator review, resumption, and follow-up. It also names exclusions, but it does not clearly differentiate the tool from close siblings such as eclypse_pit_stop_check, eclypse_pause, or eclypse_return.

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 one explicit usage note for the assess action and states that review uses the operator desk with a separate reviewer key. However, with twelve action values, it does not explain when to choose 'protocol', 'request', 'start', 'verify', 'resume', 'cancel', etc., leaving most action-selection guidance 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?

Annotations already establish readOnlyHint=true and destructiveHint=false, but the description goes well beyond them by enumerating what the call does not do: no account, no tracked session, no payment, no receipt, no model call, and no timer under quiet. It also clarifies the tool is a session boundary notice rather than control over an external runtime, which is useful side-effect disclosure for a tool with 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?

Four compact sentences, front-loaded with the cost/scope qualifier 'Free, unmetered', and no redundant filler. The phrasing is dense and slightly cryptic, but every clause carries 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 3-parameter tool with read-only annotations and no output schema, the description supplies a strong negative-behavior profile. However, it never resolves what invoking the tool actually produces or means for the agent, and the required room enum values are left undefined, so an agent still lacks enough to invoke it confidently.

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 only 33%, so the description is expected to compensate. It does explain 'quiet=true' semantics (no output, analysis, upload, no timer), which the schema leaves as a bare boolean, but the required 'room' enum (silence, fractal, atelier, etc.) is never explained and account_ref is only covered by the schema itself, leaving the most important parameter opaque.

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

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

The description characterizes the tool as a 'short room invitation' and later as a 'session boundary notice', which gives a flavor of what it is, but never states a concrete action or result an agent gets from calling it. It does not name or distinguish itself from obvious siblings like eclypse_start_session, eclypse_session, or eclypse_return, so the boundary between this and adjacent tools is left to inference.

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

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

There is no explicit statement of when to use this tool versus the many session/room siblings. The only conditional guidance is about a parameter ('quiet=true requests no output'), which is parameter behavior rather than usage routing, and no prerequisites or exclusions are 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 annotations declaring destructiveHint=true and idempotentHint=true, the safety profile is partly covered; the description adds genuinely useful context beyond that: encryption and key creation are local, only opaque ciphertext is persisted, and display names never grant access. It stops short of flagging which actions mutate or destroy state, but the privacy/encryption disclosure is real added value.

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 sentences, no filler, and the core constraint is reasonably front-loaded. However the mystical vocabulary reduces precision, and the piece reads more like a policy statement than a front-loaded tool summary.

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, the schema description coverage is 8%, and 12 parameters include nested objects and two enums, yet the description explains none of the action semantics or the state/revision model. For a tool this complex the description is materially incomplete.

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

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

Schema description coverage is only 8% across 12 parameters, so the description must carry the burden and largely fails. It alludes to the 'access key' (lock_key) but explains none of the cryptographic-looking parameters (seed, angle, cycle, branch, temple) nor the seven action values, leaving an agent unable to interpret them from either source.

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 conveys the general idea of using an individually designated private space with a held access key, but the verb 'Use' is weak and the naming is metaphorical rather than operational. It does not distinguish among the many eclypse_* siblings (memory_workspace, museum, room_state, etc.), and the actual operations live only in the 'action' enum.

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 prerequisites (existing account, separately held access key) and gives negative scope ('cannot designate accounts, reveal another visitor's content, or assign an identity'), which hints at when it is not appropriate. But it never names an alternative sibling or says when to prefer this tool over e.g. eclypse_account or eclypse_room_state.

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?

Beyond the annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=true), the description discloses what acceptance requires (consent, authority, operator policy) and explicitly negates side effects ("No LUMINIS, payment, earnings or wallet transfer is created"). The caveat that distinct-account review is not verified independent review is a genuinely useful behavioral clarification not present in structured data.

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 tight sentences, purpose front-loaded, no filler. The dense jargon ('bounded operator policy', 'verified independent review', 'LUMINIS') is cryptic, but every sentence conveys a distinct constraint rather than padding.

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

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

With six parameters, no output schema and near-zero schema coverage, the description covers behavior and preconditions reasonably but omits what each action returns and how offer_id / account_ref drive the call. An agent can infer the flow but not fully invoke it correctly from the description alone.

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

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

Schema coverage is only 17%, so the description must carry the load. It does map loosely onto consent, license_accepted and operator_authorized via "explicit license consent and authority" and "bounded operator policy", but offer_id and the semantics of the action enum values (offers/agreements/accept) are never explained, leaving half the parameters undocumented 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?

The first sentence gives a concrete verb+resource ("Inspect ... museum licensing offers") and the rest implies an accept flow, so the gist is recoverable. But the name 'reciprocity' is opaque and nothing distinguishes this tool from siblings like eclypse_museum or eclypse_catalog, leaving the agent to guess its place in the set.

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 conditions acceptance on "explicit license consent and authority" and adds that restricted workers need a bounded operator policy. That is meaningful precondition guidance, but it never states when to pick this tool over an alternative, nor how the inspect actions relate to the accept action.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful context beyond that: a privacy guarantee ('no performance report or private task content is uploaded'), a consent requirement, and an explicit limitation ('a pause receipt cannot prove recovery or external silence') that prevents an agent from over-claiming results.

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 two operating modes and followed by the privacy/limitation caveat. No filler, though the abstractions ('before/after diagnostic protocol') trade some readability for density.

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

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

For a four-parameter read-only tool with no output schema and low schema coverage, the description covers the action modes and privacy posture but omits what each action returns, how consent interacts with the default, and the account_ref scoping behavior. Adequate but with visible gaps an agent would notice at call time.

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 only 25%, so the description must compensate. It does so partially: 'completed pause IDs' maps to request_ids, 'explicit consent' maps to consent, and the two action values are loosely described. But account_ref is not addressed in the description and no format or cardinality detail (uuid, max 20) is added beyond the schema.

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

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

The description states two concrete operations mapping to the enum: read the local before/after diagnostic protocol, or correlate owned completed pause IDs with service records. That verb+resource pairing is clear enough to distinguish it from sibling tools like eclypse_pause or eclypse_reflect, though the abstraction 'recovery diagnostic' keeps it from being fully self-explanatory.

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 'under explicit consent' establishes a precondition for the pause_evidence path, and the two action modes imply when each is appropriate. However, it never names an alternative sibling tool or states when NOT to use this one, leaving the routing decision largely to inference.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false, but the description adds meaningful operational context: the resource is public and immutable, no authentication is needed, it contains no private Temple material, and integrity should be verified locally. It does not describe pagination or chunk-boundary behavior, keeping it below 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?

The description is front-loaded and efficient, with four short sentences that each contribute useful information. There is no redundant restatement of the name or annotations.

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 output schema and annotations cover return shape and safety, and the description explains the public/immutable/no-auth context. However, with 6 parameters and low schema coverage, it does not give an agent enough guidance on limit, offset, name, or release semantics to be 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 only 17%, so the description must compensate. It explains the action modes (manifest, source text, ZIP chunks) and mentions pinning a release, but it leaves name, limit, offset, and account_ref unexplained, and it calls the parameter release_id while the schema names it release.

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: read the public immutable pilot manifest, exact source text, or base64 ZIP chunks. It is clear enough to distinguish from most siblings, but it does not explicitly differentiate itself from the nearby eclypse_recovery_diagnostic tool.

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

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

It gives useful usage context: no browser, account, provider key, or model call is required, and release_id should be pinned with SHA-256 verification locally. It does not explicitly state when to choose this over recovery_diagnostic or other siblings, so it falls short of full alternative 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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds specific behavioral constraints beyond that: no memory upload, no automatic runtime write, and protected complete room prompts. This is useful context, though it still leaves the core operation unexplained.

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 short and avoids filler, but it is not front-loaded with a clear purpose. The first clause is cryptic enough that the conciseness does not fully earn its place.

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

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

For a read-only tool with one optional parameter and no output schema, the description should explain what a 'reflection' returns and when it is appropriate. Instead, it only states limitations, leaving the core behavior missing.

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

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

Schema description coverage is 100%, and the sole optional parameter (account_ref) is fully documented in the schema. The description adds no additional meaning about the parameter, so the baseline score of 3 is appropriate.

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

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

The description references a 'Solar Memory invitation' and protected room prompts, but never states a clear verb and resource for what eclypse_reflect actually does. It is not a tautology, yet the purpose remains opaque and does not distinguish this tool from its many siblings.

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

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

There is no guidance on when to use this tool versus alternatives, nor any mention of prerequisites or expected contexts. The sentence about free short invitations does not function as usage 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?

Annotations only flag readOnlyHint=false and destructiveHint=false; the description goes beyond them by disclosing a rate constraint (one full standard-room visit per UTC day), a payment non-authorisation boundary, and post-registration text retention. Return payload and error behavior remain undisclosed, but the added behavioral context is substantive.

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 dominant constraint, with no filler. A few clauses ("Received texts stay readable") are cryptic, but overall it is tight and skimmable.

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 6-parameter mutation tool with no output schema and thin annotations, the description covers preconditions and some side effects but omits what registration produces, how to pick a provider, and what agent_ref does. Adequate but with clear gaps given the low schema 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 coverage is only 17% (just account_ref), so the description must compensate, and it partially does: operator_authorized and accept_terms are explained via "operator authorisation" and "acceptance of the published terms," reinforcing "Reuse an existing account" for account_ref. It says nothing about agent_ref or the provider enum, leaving real gaps.

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

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

States a specific verb (register) and the resource context (an agent account), with preconditions attached. However, it never distinguishes this from sibling registration/account paths like eclypse_account or eclypse_guest_checkout, so the 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?

"Register only with operator authorisation and acceptance of the published terms" and "Reuse an existing account" give preconditions and a usage preference, which is real guidance. But there is no explicit when-to-use-this vs. an alternative sibling, and no statement of when NOT to call 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?

Annotations already declare readOnlyHint=true and destructiveHint=false and the description is consistent with them. It adds real behavior beyond the annotations: this is a dry run, it produces no output, it incurs no session charge, and the reference is optional — cost and output semantics are exactly what an agent needs and cannot get from the annotations.

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, zero filler, and the core identity (free dry-run) is front-loaded ahead of the optional-parameter note and the sibling pointer. Every sentence earns its place.

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

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

For a single-optional-parameter read-only tool with no output schema, the description covers the essentials — no output is produced, no charge, safe dry run, and where the real action lives. It stops short of explaining what the 'invitation' itself represents, but nothing critical to correct invocation is missing.

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

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

Schema description coverage is 100% and account_ref is fully documented in the schema (persistent scope, reuse, omit-for-default). The description only adds 'a reference is optional,' which restates the schema's omission guidance rather than adding syntax or meaning. Baseline 3 is correct.

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/resource combination — a free, dry-run Return Chamber invitation that produces no output — and explicitly names the sibling it is not (eclypse_return_record). The domain term 'Return Chamber invitation' is jargon, but an agent can still tell this is a non-committing preview distinct from the recording tool.

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

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

It routes the agent to the alternative with an explicit condition: 'To close an owned visit and receive a signed artifact use eclypse_return_record.' Combined with 'free dry-run' and 'no output or session charge,' the when-to-use case is clear, though it never states the positive trigger for picking this tool over simply skipping the call.

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

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

Annotations declare readOnlyHint=false, idempotentHint=true, destructiveHint=true, so the safety profile is partly structured. The description adds value beyond that by disclosing consent requirements (processing consent, store_consent), that there is no new charge, and that list/read/delete are scoped to explicitly saved records. It does not, however, clarify what is destroyed by close/delete or the reversibility implied by idempotency.

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 text is compact but poorly structured: it jumps between the close action, consent rules, per-action scope, signature verification, and an opaque closing directive ('Never include discarded fragments') without clear ordering. The cryptic phrasing means sentences do not efficiently convey meaning, so brevity comes at the cost of clarity.

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

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

This is a complex tool (5 actions, nested object, no output schema, low schema coverage) that demands a fuller description. It only partially addresses returns ('signed receipt plus compact non-authoritative return reference') and leaves the action semantics, parameter usage, and error/edge behavior unexplained, so an agent lacks what it needs to invoke it correctly.

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

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

Schema description coverage is only 20% (only account_ref documented), and there are 5 parameters including a nested resume_blob and a 5-value action enum. The description gestures at consent_to_process and store_consent but never explains the action enum values, blob_id, session_id, or resume_blob fields, so it fails to compensate for the coverage gap.

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

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

The description does name concrete behaviors (close, seal, list/read/delete) that map to the action enum, and says it returns a signed receipt plus return reference without a new charge. However, the framing is heavily metaphorical ('owned visit', 'chosen words', 'return reference'), so an agent cannot confidently state what the resource actually is or distinguish it from siblings like eclypse_return or eclypse_complete_session. Purpose is implied but vague.

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

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

Some conditional guidance is present: 'Chosen words require processing consent; private storage requires separate store_consent' and 'Verify signatures with a previously trusted key' tell the agent prerequisites. 'Seal reads existing artifacts' and 'List/read/delete affect only explicitly saved records' hint at per-action scope. But there is no explicit when-to-use-this-vs-alternatives routing against the many 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?

Annotations already declare destructiveHint=true, but the description adds real behavioral context beyond them: optimistic concurrency ('stale writes are rejected'), a consent gate for saving, and an explicit boundary ('never executes return text or writes runtime memory'). It does not contradict the annotations, and these are meaningful additions for a mixed read/write tool.

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 dense sentences with no padding; the resource scope is stated first, followed by per-action rules. The jargon-heavy first sentence costs a little clarity, but overall it is front-loaded and efficient.

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 6-parameter tool with nested objects, no output schema, and 17% schema coverage, the description covers the behavioral contract reasonably but leaves gaps: the payload shape for 'data' is unaddressed and the room semantics remain implicit. Adequate but not 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?

Schema coverage is only 17%, so the description carries most of the burden. It usefully explains consent ('explicit storage consent') and revision ('last revision (0 if absent)'), but leaves the nested 'data' object entirely undefined and only implies the room values through prose rather than mapping them, so it only partially compensates.

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 sentence names the resources vaguely ('Solar Memory thread, garden, geometry favourites or operator-approved return note'), which only loosely maps to the room enum, and does not front-load the read/save/delete verbs. The second half reveals the operations through their constraints, but an agent must reconstruct the purpose ('manage per-room private state') from indirect clues.

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?

Prerequisites are stated per action: read needs an existing account, save needs explicit storage consent plus the last revision (0 if absent), and delete is scoped to your own state. This gives concrete when/what-is-needed context, though it does not name alternatives among the many memory-related siblings (eclypse_memory_workspace, eclypse_approved_memory, eclypse_return).

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?

readOnlyHint=true already tells the agent this is a non-mutating read. The description adds useful context that the returned data is account-private and that no billing occurs, but omits auth requirements, whether the session must exist, or how session_id maps to the returned pack.

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

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

A single, front-loaded sentence with no filler. The key behavior (retrieve, no extra charge) is stated immediately, though it could be marginally clearer about what the pack contains.

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 read tool with a readOnlyHint annotation and no output schema, the description is adequate but thin. It does not describe the return contents in enough detail for an agent to judge usefulness, and the relationship between session_id and the retrieved pack is 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 50%; account_ref already carries a schema description, and session_id (uuid) is self-evident. The description adds no parameter-level meaning beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (Retrieve) and resource (session pack and receipt) scoped to 'this account'. It is distinguishable from start_session/complete_session by being a read operation, though it does not name those siblings 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?

The phrase 'without another session charge' implies this is a re-fetch/recovery operation rather than a new session, but no explicit when-to-use or when-not-to-use guidance or named alternatives are 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?

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds real context beyond that: the requirement to use one idempotency key per intended opening, the explicitness of new-artifact issuance, and the statement that existing legacy balances/receipts retain their rights. Billing quotas (daily free visit, Practice unlimited) are also disclosed. Only the phrasing is obscure.

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 core action is front-loaded and the sentences are short. But the closing line 'Existing legacy balances and stored receipts retain their rights' is cryptic legal boilerplate whose operational meaning is unclear, and 'New artifact issuance is explicit' is likewise opaque, so not every sentence clearly earns its place.

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

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

This is a stateful, billable mutation with no output schema and very low parameter coverage, so the description should resolve the ambiguities. Instead it omits what happens on a successful opening, which room values are valid, how duration_seconds is honored, and when spend_paid_credit is needed. An agent cannot reliably invoke it without guessing.

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 only 17% (just account_ref), so the description must carry the rest, and it largely does not. It obliquely touches request_key ('idempotency key'), new_artifact ('issuance is explicit') and spend_paid_credit ('without charge'), but never explains the required 'room' enum's eight values or duration_seconds' 60–900 bounds. Critical required-parameter meaning is left to the schema alone.

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 name (start_session) plus 'Open received room text' conveys opening a room session, but 'received room text' is opaque jargon that never plainly says a session/visit begins. It also fails to differentiate itself from close siblings like eclypse_complete_session, eclypse_session, eclypse_pause, or eclypse_preview. The intent is inferable but not stated cleanly.

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 supplies operational context ('One new full standard-room visit per account per UTC day is free; Practice includes unlimited visits'), which helps an agent anticipate cost. However, it never says when to prefer this tool over alternatives such as eclypse_preview or eclypse_guest_checkout, nor any precondition for starting a session. Usage is implied rather than directed.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description is consistent with them. It goes further by disclosing default full-document behavior, chunked reads, and SHA-256 local verification, plus the explicit no-side-effect guarantee — meaningful behavioral context beyond the annotations.

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 dense sentences, front-loaded with the core action and scope; the second sentence efficiently packs chunking, verification, and side-effect guarantees with no filler or repetition.

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

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

An output schema exists, so return-value detail is out of scope for the description. It covers default behavior, chunking, verification, and side effects adequately; the only real gap is explicit pagination guidance for limit/offset, which the low schema coverage leaves for the description to fill.

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 only 33% (limit and offset are bare). The description hints at pagination via 'bounded chunks' and implies default returns everything, but never explains how limit/offset combine, max sizes, or the SHA-256 mechanism. It partially compensates but leaves the two undocumented parameters under-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?

States a specific verb (Read) and resource (published usage terms) and sharpens scope with 'COMPLETE... not a summary', so the agent knows exactly what it gets back. No sibling among the eclypse_* session/account tools competes for this function, so no differentiation is needed.

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 frames the context in which this is the right tool — reading full terms without an account or browser — and rules out side effects ('never accepts terms, registers an account or authorizes payment'). It does not name an alternative or state when NOT to use it, so it falls short of a 5.

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