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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that an objective is registered and a flow is returned, but it omits any information about authentication requirements, side effects, whether the operation is destructive or reversible, rate limits, or error behavior.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the action and the return flow efficiently.

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

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

For a seven-parameter mutation tool with no annotations and no output schema, the description is too thin. It does not explain the return format to compensate for the missing output schema, nor does it clarify prerequisites or how this tool relates to similar siblings like aureon_create_objective.

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 every parameter is already documented in the input schema. The description adds no additional parameter semantics beyond what the schema provides, which matches the baseline of 3 when the schema does the heavy lifting.

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

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

The description uses a specific verb ('Register') and resource ('user/agent intent as an Automatic objective'), and it states that the tool returns an 'AI → objective → portfolio flow'. It is clear what the tool does, though it does not explicitly differentiate itself from sibling tools like aureon_create_objective.

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

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

The description implies usage ('Register user/agent intent') but provides no guidance on when to use this tool versus alternatives such as aureon_create_objective or aureon_update_objective. There are no exclusions, prerequisites, or conditions mentioned.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only supplies 'controlled' and 'optionally auto-restore'. It omits whether permissions are required, whether the shock is reversible, and what side effects occur on portfolio marks. The richest behavioral detail (409 on non-executable vault) lives in the schema, not the description.

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 the mutation intent stated first and the optional behavior trailing. Efficient, though borderline terse for a mutation tool in a complex domain.

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

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

For a no-annotation mutation tool with no output schema in a portfolio-risk domain, the definition is thin: it omits auth/authorization needs, reversibility, and side effects. The schema compensates on parameter detail but not on operational context.

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 every parameter is already documented in the schema (including the autoRestore 409 caveat). The description adds no syntax, format, or constraint information beyond that, 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?

Specific verb+resource+target: 'Apply a controlled market event to portfolio marks'. An agent can tell it mutates portfolio marks. It does not, however, differentiate itself from near siblings like aureon_list_market_presets or aureon_apply_financial_intent.

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, when-not-to-use, prerequisites, or named alternatives. The 'optionally auto-restore' phrase hints at a behavior toggle but provides no selection guidance.

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

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

With no annotations, the description carries the full burden and does disclose the key behavioral traits: it is non-mutating ('does not send the hire') and non-signing, and it enumerates the return values (allow, refuse, authorization_required). It omits auth requirements and any idempotency/rate-limit context, so it is strong but not complete.

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, each earning its place: the purpose, the return values, and the side-effect boundary. The core purpose is front-loaded with no filler.

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

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

No output schema exists, but the description compensates by naming the three return values, and the side-effect boundary substitutes for missing annotations. The main gap is that it does not explain what an 'authorization_required' result implies or what the caller should do next.

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%, including the nested action object (type must be 'hire', asset, amount, agent), so the schema does the heavy lifting. The description adds no syntax, format, or constraint detail beyond what the schema already provides, making the baseline 3 appropriate.

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

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

The description states a specific verb (check) and resource (one proposed agent hire) against the wallet's financial objective, and names the three possible outcomes. This is enough to tell it apart from generic read siblings, but it never addresses the adjacent aureon_get_policy_check sibling, which an agent could easily confuse it with.

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

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

Usage is only implied: 'Does not send the hire and does not sign' signals a dry-run pre-check, so an agent can infer this precedes an actual hire. However, it never states when to prefer this over aureon_get_policy_check or how it relates to aureon_run_execution, 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?

With no annotations, the description carries the full burden. It does disclose the scope of destruction ('all capital-book positions') and implies an auth requirement ('authenticated wallet'), which is real behavioral information. It says nothing about irreversibility, whether positions are deleted versus zeroed, or downstream side effects on objectives/executions.

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, which is well-sized for the operation. It is slightly thin for the risk profile of the action, but nothing is wasted or buried.

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 destructive, no-parameter, no-output-schema mutation with zero annotations, the description leaves critical questions unanswered: is it reversible, what happens to objectives/executions that depend on the cleared positions, and what a successful clear returns. The agent cannot safely predict the outcome.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool is 4. The description correctly implies no filtering or selection options exist.

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

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

States a clear verb (clear) and resource (capital-book positions for the authenticated wallet), so the intent is unambiguous. However, it does not distinguish itself from siblings like aureon_set_portfolio, aureon_sync_portfolio, or aureon_get_portfolio, which operate on the same resource.

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

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

No when-to-use guidance, no prerequisites, and no mention of the nearest alternatives (aureon_set_portfolio or aureon_sync_portfolio) that could plausibly be confused with this one. The agent must infer usage entirely.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose that this is a manual backfill that verifies on chain and mutates state by attaching a settlement record, which is useful. But it says nothing about idempotency (what happens if the execution is already settled), required permissions, or reversibility of the attached record — meaningful gaps for a write operation.

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 zero filler; the primary purpose and the 'Manual backfill' qualifier are front-loaded ahead of the usage condition and the exclusion. 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 two-parameter tool with no output schema and no annotations, the description covers purpose, trigger, and one hard exclusion, which is close to sufficient. What it omits is failure/duplicate behavior on the settlement attach and any indication of what the tool returns, but those are modest gaps at this complexity level.

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

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

Schema coverage is 100% and both parameter descriptions already say 'Execution receipt id' and '0x vault Rebalanced transaction hash'. The description's mention of a 'vault Rebalanced transaction on chain' merely restates the transactionHash schema text, so it adds no syntax, format, or sourcing detail beyond structured fields. 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?

States a specific verb chain (verify an on-chain transaction and attach a settlement record) against a specific resource (execution settlement). The 'Manual backfill' framing immediately separates it from the read-side siblings aureon_get_execution_settlement and aureon_list_settlements, so an agent can route correctly without opening any schema.

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

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

Gives an explicit trigger ('Use when the listener missed the event') and an explicit exclusion ('Staged executions cannot be confirmed this way'), which is the when/when-not pair an agent needs. No alternative sibling is named, but the manual-vs-listener framing makes the alternative path self-evident.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the backend effect (verifies the receipt on chain, stores the registry link), which tells the agent this is a state-mutating confirmation. However, it omits auth requirements, idempotency (safe to call twice?), and behavior when the receipt is not found or is still pending.

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 precondition front-loaded and zero padding. 'Pass the transaction hash' is mildly redundant with the schema, but nothing else 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 write/confirmation tool with no annotations and no output schema, the description covers the workflow and the server-side effect but leaves gaps on authorization, retry/idempotency, and failure handling. Adequate to invoke correctly, not complete for an agent reasoning about consequences.

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%, so both parameters are already documented in the schema. The description's only parameter-related content is 'Pass the transaction hash,' which restates the schema and adds no format or sourcing detail beyond it. 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 (confirms) and resource (on-chain ObjectiveRegistry registration), and situates it in a workflow by tying it to the prepare tx the host wallet broadcast. An agent can separate it from the prepare/get siblings, though the description never names them explicitly.

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

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

Gives clear usage context: call this after the host wallet has broadcast the prepare transaction. The precondition is explicit, but there is no when-not guidance (e.g. what to do if no transaction was broadcast, or how this differs from registry_status/get_objective_registry).

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

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

With no annotations, the description carries the full burden and does reasonably well: it discloses the verification rule ('verified only when the signature recovers to the session wallet') and an important negative side effect ('Does not broadcast'), which tells an agent this is not an on-chain action. It omits auth/prerequisite requirements and what occurs on a failed recovery, so it stops short of full transparency.

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, each carrying distinct information: the action, the verification condition, and the absence of broadcast. The action is front-loaded and there is no filler.

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

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

There is no output schema and no annotations, so the description should cover behavior and result. It covers the verification rule and non-broadcast nature but says nothing about what is returned, idempotency, or what happens when the signature fails to recover, leaving gaps for a confirmation-style mutation 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 100% and all three parameters are documented there (message, reportId, signature), so the schema already does the work. The description adds no syntax, format or coupling details beyond that, which is the expected baseline of 3 when the schema is complete.

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

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

The description names a specific verb (store) and resource (a wallet signature for a prepared report), making the operation distinct from siblings like aureon_prepare_report, aureon_get_report and aureon_list_reports. It does not name those siblings explicitly, so the differentiation is inferable from the phrase 'prepared report' rather than stated.

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

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

The phrase 'for a prepared report' implies this is the follow-up step to aureon_prepare_report, and the schema's 'Exact message returned by prepare' reinforces the sequencing. However, there is no explicit statement of when to call this, no named alternative, and no exclusion of the other confirm_* tools (restoration, objective registry, execution settlement).

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the tool checks the receipt and does not sign or broadcast, which prevents an agent from mistaking it for an execution tool. It still omits auth/session requirements, idempotency, and the precise side effect of 'store' in this 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 short sentences, front-loaded with the core action and followed by constraints. It is efficient and avoids repetition, though the first sentence is grammatically awkward and slightly harder to parse than necessary.

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 confirmation/store tool with no annotations and no output schema, the description gives important behavioral limits and the receipt-checking action. It still leaves the return behavior, permissions, and idempotency unclear, which would help an agent invoke and interpret the result more reliably.

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 objectiveId and transactionHash are already documented in the schema. The description adds no parameter-specific syntax, format, or constraint beyond what the schema provides, which meets the baseline when the schema does the heavy lifting.

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 action on a specific resource: store a vault rebalance that the session wallet already broadcast, plus receipt checking. It distinguishes itself from execute/propose siblings by saying it does not sign or broadcast. The only weakness is that it says 'vault rebalance' rather than 'restoration,' which slightly blurs alignment with the tool name and sibling confirm/restore tools.

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

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

The phrase 'session wallet already broadcast' implies this is used after an external wallet broadcast, and 'Does not sign or broadcast' rules out execution use. However, it does not explicitly name alternatives such as aureon_propose_restoration or explain when-not to use this versus other confirmation tools.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose the single most important trait: the secret is returned only once and must be stored immediately. However, it says nothing about authentication/permission requirements, whether key creation can be undone, or rate limits on key issuance.

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

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

One sentence with the action front-loaded and the critical caveat in a tight parenthetical. No filler, nothing to trim.

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

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

For a single-parameter mutation with no output schema, the description covers the essential gotcha (one-time secret) and the schema covers the parameter, so an agent can invoke it correctly. Minor gaps remain around auth requirements and what the response contains besides the secret.

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

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

Schema description coverage is 100% for the single `name` parameter, so the schema already documents its meaning. The description adds no syntax, format, or naming-convention detail beyond what the schema provides, matching the baseline of 3 when the schema does the heavy lifting.

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 ("Create an SDK API key") that an agent can distinguish from sibling key-management tools like aureon_list_api_keys, aureon_revoke_api_key, and aureon_toggle_api_key. It does not explicitly name or contrast those siblings, so it stops short of a 5.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives for provisioning credentials. The creation intent is implied by the verb but nothing routes the agent between this and the other api_key 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?

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the irreversibility of two fields and the default automationMode=auto, which is genuine mutation context. However, it says nothing about required permissions/wallet auth, what the create returns (no output schema exists), or side effects such as keeper vault behavior mentioned in the schema description.

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 core action and immediately followed by the highest-risk constraint (locked fields) and the default. No filler or redundant phrasing.

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

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

For a 14-parameter creation tool with no annotations and no output schema, the description covers the immutability trap and default but omits what the caller receives back (objective id), auth requirements, and any validation behavior. The rich schema compensates for parameter detail, leaving the description adequate but incomplete.

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

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

Schema description coverage is 100%, so the schema already documents all 14 parameters, including the 'locked after create' notes on targetSymbol and automationMode. The description's field guidance largely repeats that structured data, so baseline 3 applies rather than a higher score.

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

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

States a specific verb and resource: 'Create a Financial Compass Objective.' An agent immediately knows this produces a new objective entity. It does not explicitly contrast with the sibling aureon_update_objective or aureon_restore_objective, but the resource is unambiguous.

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

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

Usage is implied rather than stated – the note that targetSymbol and automationMode are locked and require recreation hints at the create-vs-update boundary, but the description never names aureon_update_objective as the alternative for modifying existing objectives or states prerequisites.

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

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

With no annotations, the description carries the full burden and does disclose meaningful behavior: it bypasses wallet signature auth and only functions when the API-side flag AUREON_ALLOW_DEV_LOGIN=1 is set. It does not say what a successful call returns (e.g. session token) or what happens if the flag is unset, but the auth/environment constraints are well covered.

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

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

A single front-loaded sentence with the core action first and the environment/prerequisite caveats in a parenthetical. Every clause earns its place; only the em-dash aside slightly interrupts flow.

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

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

For a zero-parameter dev-only endpoint with no output schema and no annotations, the description supplies the essential context: what it does, the server-side prerequisite, and the production exclusion. The only gap is the return/credential behavior on success.

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

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

The tool takes zero parameters, so there is no parameter surface for the description to document and the baseline of 4 applies. There is no misleading parameter content.

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 ('login') and immediately qualifies the mechanism ('without wallet signature'), which implicitly distinguishes it from the wallet-based auth siblings like aureon_verify_wallet. It stops short of naming a sibling explicitly, so it is clear but not maximally 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?

Gives a clear use context ('Local preview') plus an explicit exclusion ('not production') and the operational prerequisite (AUREON_ALLOW_DEV_LOGIN=1). This tells the agent when to reach for it versus the production auth path, though it does not spell out 'use X instead' alternatives.

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

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

No annotations exist, so the description carries the full burden. It discloses the return content (per-objective current weight vs target, plus a flag), which is useful given there is no output schema, but it says nothing about authorization requirements, scoping, or what the 'green-book/off-plan paradox flag' actually signals.

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 compact sentence, front-loading the core comparison before the secondary flag. Efficient, though the unexplained domain jargon ('green-book/off-plan paradox') costs a little 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?

For a zero-parameter read tool with no output schema, the description adequately sketches the return shape (per-objective weight vs target plus a flag). It would be stronger if it decoded the paradox flag, but nothing essential to invoking the tool is missing.

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

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

The tool takes zero parameters, so there is nothing for the description to clarify; the baseline for a no-parameter tool is 4. No parameter confusion is possible here.

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

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

Names a specific resource (per-objective allocation vs policy target) and the comparison it performs, which reads clearly as distinct from the raw holdings returned by aureon_get_portfolio. However, it never names an alternative tool, so differentiation from siblings like aureon_check_policy or aureon_get_overview must be inferred.

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 states what the tool returns but gives no guidance on when to call it versus aureon_get_portfolio, aureon_check_policy, or aureon_get_objective_portfolio_flow. No prerequisites, no exclusions, no context for selecting it.

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

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

With no annotations, the description carries the full burden but does add genuine behavioral content: 'Missing proof is labeled' and 'Never invent on-chain claims' tell the agent how to treat incomplete or unverifiable data. It says nothing about authentication requirements, whether the operation is read-only, export size, or pagination.

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 fragments, front-loaded with the action verb, with no padding. The telegraphic style is efficient though slightly clipped, and the integrity constraint lands before the enumerations.

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/export tool with no output schema, the description usefully enumerates what the export contains and how missing proof is handled. It still omits the shape/format of the returned export and any limits, which an agent would need to consume the result.

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?

One parameter with 100% schema description coverage, so the schema already defines objectiveId completely. The phrase 'for one objective' reinforces the single-objective scope but adds no format or validation detail 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?

States a specific verb and resource ('Export the financial audit trail') scoped to 'one objective', and enumerates the four content sections (registry, receipts, settlements, timeline). It does not distinguish itself from the sibling tools that expose those same artifacts individually (aureon_get_objective_registry, aureon_list_settlements, aureon_list_timeline), leaving the agent to infer that this is a composite export.

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

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

No when-to-use statement, no prerequisites, and no mention of alternatives such as calling the registry/settlement/timeline tools separately. Usage is only weakly implied by 'for one objective'.

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

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

With no annotations provided, the description carries the full disclosure burden. It conveys that the call issues a nonce/message intended for EIP-191 signing and that it is optional in API-key flows, but says nothing about nonce lifetime/expiry, single-use semantics, or that the call is a safe read-like generation — meaningful behavioral gaps for an auth primitive.

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 tight sentence with the core action front-loaded and the optionality caveat appended. No filler or redundancy.

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

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

For a one-parameter, no-output-schema auth helper, the description plus schema is nearly sufficient: it names the purpose and the EIP-191 signing context and flags the optional case. The omission of nonce lifecycle/expiry behavior is the only notable gap.

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

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

There is a single required parameter (address) with 100% schema description coverage, so the schema already defines it and the baseline is 3. The description adds no format or constraint detail beyond what the schema provides.

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 (Request) and resource (wallet auth nonce/message) and names the downstream protocol (EIP-191 signing), which lets an agent distinguish it from generic auth siblings like aureon_dev_login and aureon_verify_wallet. It stops short of explicitly contrasting itself with those siblings, so it is clear but not fully differentiated.

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

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

The parenthetical 'optional — issued API keys usually skip this' gives a concrete when-not-to-use condition, which is useful routing guidance. It does not name the alternative flow (e.g., dev_login or create_api_key) to use instead, 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.

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: no auth requirements, no read-only confirmation beyond the word 'get', no not-found or error behavior, no indication of return shape. Only the safest inference (read-only lookup) is available.

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 very short and front-loaded, but the terseness reads as under-specification rather than efficiency, since a complete sentence could have carried the same idea with more useful context.

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

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

With no annotations and no output schema, the description is the sole source of context, and it omits what a decision record contains, whether the id comes from aureon_list_decisions, and what happens on a miss. For a single-param lookup the burden is modest, but the gaps are real.

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?

There is one parameter with 100% schema description coverage, so the schema already documents 'id'. The description adds no format, source, or provenance detail about where a decision id comes from, leaving it at the baseline for a fully covered 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 fragment names a specific verb (get) and resource (decision record) scoped to a single id, so the operation is identifiable. It does not distinguish itself from the sibling aureon_list_decisions, so it stops short of a 5.

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

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

No when-to-use guidance, no mention of aureon_list_decisions as the alternative for enumerating decisions, and no stated prerequisites. Usage must be inferred entirely from the name.

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

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

No annotations are provided, so the description carries the full burden. 'Read' implies a non-mutating operation, but there is no disclosure of auth requirements, whether the flow is computed live or cached, or what stages are returned. Given zero annotation coverage, this is a significant gap.

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

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

A single front-loaded line with no filler; the arrow notation compresses the process stages efficiently. Slightly terse to the point of opacity, but no waste.

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

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

With one optional parameter and no output schema, the description should explain what the 'flow' returns and in what form. As written, an agent knows neither the response shape nor how this differs from the demo/plan siblings, making it incomplete for a read tool of this apparent complexity.

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

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

The single parameter objectiveId has 100% schema description coverage ('Filter to one objective (omit for all active)'), so the schema already does the work. The description adds nothing about the parameter, so baseline 3 applies.

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

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

The verb 'Read' plus the arrow sequence 'drift → detection → restore flow' conveys a multi-stage read operation on objectives, which is more specific than a bare noun. However, 'flow' is ambiguous (workflow definition? live state? staged results?) and it is not differentiated from close siblings like aureon_run_drift_restore_demo or aureon_get_restore_plan, so an agent cannot confidently pick it.

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?

'for active objectives' hints at scope and the schema notes omitting objectiveId covers all active, but there is no explicit when-to-use, when-not-to-use, or named alternative. The agent is left to infer whether this is a preview/read versus the demo or restore-plan tools.

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

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

With no annotations, the description carries the full burden and does disclose a valuable behavioral trait: results only exist after an on-chain Rebalanced event, and staged executions yield none. It does not cover failure semantics (error vs. empty), permissions, or response shape, 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?

Two tight sentences, front-loaded with the core purpose and followed by the key caveat. No filler or redundancy; a compact, well-ordered description.

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

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

For a simple one-parameter getter with no output schema, the description covers purpose, data-existence conditions, and the crucial warning against claiming on-chain proof. Minor gaps around return format and error behavior keep it from a 5.

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

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

Schema description coverage is 100%, so the schema already documents the single executionId parameter. The description adds no syntax, format, or source guidance for the id, so it earns only the baseline 3 for high-coverage schemas.

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

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

The description gives a specific verb and resource: 'Returns the chain-verified settlement record for a vault execution.' This distinguishes it from the list/confirm siblings (aureon_list_settlements, aureon_confirm_execution_settlement) at the noun level, 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?

It states the condition under which the record exists (listener observed an on-chain Rebalanced event) and a clear exclusion (staged executions never have settlement records). It lacks explicit routing to alternatives such as list_settlements or confirm_execution_settlement, so it stops 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.

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

No annotations are present, so the description carries the full behavioral burden. "Read" implies a safe, non-mutating operation and the filtering constraint (only active objectives with a receipt) is disclosed, but there is no statement of return shape, pagination, or whether it triggers any state change beyond the read.

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 wasted words. It is dense with jargon rather than explanatory, but it is appropriately sized for the tool.

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

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

With no output schema and no annotations, the description is the only source of truth, and it does not explain what a "full AUREON loop" result contains or how the receipt is represented. It scopes the call adequately but leaves the agent guessing about the response.

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

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

Schema description coverage is 100%, so the schema already documents both parameters, setting the baseline at 3. The description reinforces objectiveId's filtering intent ("active objectives") but adds nothing for the "brief" parameter beyond the schema's own "User brief for teaching shape".

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

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

States a specific verb (Read) and resource (full AUREON loop) plus scope (active objectives with a latest execution receipt). It is distinguishable from the sibling aureon_run_full_aureon_loop_demo by the read vs run framing, but the description never names a sibling or defines what the "loop" actually comprises, which is domain jargon.

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

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

No when-to-use guidance, no prerequisites, and no routing against the many alternatives in this family (e.g. aureon_run_full_aureon_loop_demo, aureon_get_objective_portfolio_flow, the other get_*_flow tools). The agent must infer applicability entirely from the scope clause.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read of current state through 'health state' and enumerates what is assessed, but says nothing about permissions/auth, whether results are live versus point-in-time, pagination, or response shape.

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 only one short phrase, so there is no waste, but it is an under-specified fragment rather than a structured, front-loaded sentence establishing the action and outcome.

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 annotations and no output schema, the description must stand alone, and it does convey the three health facets returned. It still omits when to prefer it over aureon_get_health_history and other objective-inspection tools, leaving a real gap for a read tool in a dense sibling set.

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

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

The single objectiveId parameter is fully documented in the schema ('Filter by objective ID (omit for all)'), so the schema does the heavy lifting. The description adds no filtering or format detail beyond that, which is the expected baseline at 100% coverage.

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

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

The description names the resource (health state) and narrows its scope to objectives, then enumerates the facets returned (drift, breach status, policy compliance). However it is a noun phrase with no verb, and it never distinguishes itself from the adjacent aureon_get_health_history, so the purpose is understandable but not sharply 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 no statement of when to call this versus aureon_get_health_history (historical) or aureon_get_objective (details), nor any prerequisite or context. Usage must be inferred entirely from the tool name.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses almost nothing: no time range, ordering, sample cadence, count limits, or whether data is paginated. The single word 'stored' is the only behavioral signal, implying persisted rather than live computation.

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 fragment is waste-free and front-loaded, but it is undersized for a tool with no annotations and no output schema. Brevity here reads as under-specification rather than crispness.

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

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

With no output schema and no annotations, the description should describe what the samples look like (fields, granularity, range). Instead it stops at a label, leaving the agent 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?

The tool takes zero parameters, so per the rubric the baseline is 4. There is nothing for the description to disambiguate beyond what the empty schema already communicates.

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 phrase names the resource (health score samples) and implies persistence ('stored'), so an agent can guess it retrieves historical health data. But it is a noun fragment with no verb and gives no differentiation from the sibling aureon_get_health, so an agent cannot tell which of the two to call.

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 when-to-use guidance, no mention of when to prefer aureon_get_health (current) over this history tool, and no prerequisites. The agent is left to infer usage entirely from the name.

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

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

No annotations exist, so the description carries the full burden and discloses almost nothing: no auth/permission requirements, no behavior for an unknown or unauthorized ID, and no return-shape hint. For a single-item read tool this is low-risk, but the disclosure gap is real.

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

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

One short, front-loaded sentence with no filler. It is efficient, though its brevity is part of why other dimensions are thin.

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 annotations and no output schema, nothing tells the agent what the returned objective looks like or whether the lookup can fail on authorization. Given the rich sibling set, a sentence on returns or failure modes would be expected.

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

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

Schema description coverage is 100% for the single objectiveId parameter, so the baseline of 3 applies. The description's 'by ID' restates the schema rather than adding format, source, or validity details beyond it.

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 (get) and resource (a single objective) plus the key selector (by ID), which implicitly contrasts with the sibling aureon_list_objectives. It does not explicitly name that sibling, so differentiation 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?

No when-to-use context, no mention of the alternative list tool, and no prerequisites. The phrase 'by ID' hints that an ID must be known, but the agent is not told where to get one or when this is preferable to listing.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Read' implies a safe non-mutating operation, but nothing is said about auth requirements, what the flow contains, or return shape — thin for a tool with zero annotation coverage.

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. It is efficient, though its terseness borders on under-specification rather than pure 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?

For a simple one-param read tool with full schema coverage this is minimally sufficient, but with no output schema and no annotations an agent must infer what a 'portfolio flow' actually returns.

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% and the single objectiveId parameter is already documented in the schema with the same 'omit for all active' semantics. The description adds no meaning beyond it, 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 (Read) and resource (AI → objective → portfolio flow), scoped to active objectives. It is distinguishable from siblings like get_portfolio or list_objectives by naming the 'flow' artifact, though the arrow notation is jargon-heavy and not 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 'for active objectives' implies tge usage context and the schema note explains omitting objectiveId returns all active. But there is no explicit guidance on when to choose this over aureon_get_portfolio or the other get_*_flow siblings.

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

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

No annotations are provided, so the description carries the full behavioral burden. It hints that a record exists only 'when registered' but says nothing about auth requirements, error behavior for unregistered objectives, or whether the read is side-effect free.

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; it is efficient, though extremely terse for a tool with a meaningful conditional (registered vs not).

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 annotations and no output schema, the description should explain what the registry record represents, how an objective becomes registered (via prepare/confirm_objective_registry), and the failure mode when it is not registered. None of that is present.

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

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

Schema description coverage is 100% (objectiveId is documented as 'Objective id'), so the baseline is 3. The description adds no format, ID-source, or lookup-semantics detail beyond what the schema already states.

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

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

States a specific verb (Returns) and resource (the on-chain registry record for an objective), which distinguishes it from the generic aureon_get_objective and the registry mutation siblings. It does not, however, explicitly name or contrast itself with aureon_get_objective or aureon_registry_status, so an agent must infer the difference.

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 clause 'when registered' implies a precondition, but there is no statement of when to call this versus aureon_get_objective, aureon_registry_status, or the prepare/confirm registry pair, and no indication of what happens if the objective is not registered.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only aggregate but says nothing about authentication requirements, whether values are live or cached, or what scope (user/workspace) the aggregates cover. For a dashboard endpoint with zero annotation coverage this is thin.

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

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

A single short clause with the resource front-loaded and no filler. It is a fragment rather than a sentence, but nothing is wasted and nothing is buried.

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

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

With no output schema and no annotations, the description is the only source of information about what the tool returns, and it does list the three aggregate values. However, it omits auth expectations and does not clarify how the aggregates relate to the more granular siblings, leaving real gaps for a zero-parameter dashboard tool.

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

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

The tool takes zero parameters, so there is nothing to document beyond what the schema already shows; the baseline for a parameterless tool is 4. The description adds the semantic meaning of the returned fields, which is a small bonus.

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 (dashboard overview) and enumerates the three aggregates returned — total AUM, objective count, aggregate health. This distinguishes it reasonably from siblings like aureon_get_health or aureon_list_objectives, though it does not use a clear verb (e.g. 'get') or explicitly contrast with those 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 statement of when to call this tool versus alternatives such as aureon_get_health, aureon_get_portfolio, or aureon_list_objectives, and no mention of prerequisites or auth state. Usage must be inferred from the name and the aggregate nature of the return fields.

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

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

With no annotations, the description carries the full burden, and it does disclose the two most important traits: no hire is sent and nothing is signed, i.e. a side-effect-free read. It says nothing about whether this actionId requires prior authorization, whether the stored decision can expire or be superseded, or any rate/access 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 short sentences, front-loaded with the purpose and followed immediately by the safety constraint. No filler and nothing repeated from structured fields.

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

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

For a single-parameter read with no output schema, the description covers purpose and the no-side-effect guarantee, but says nothing about the shape of the returned decision, and the name/description mismatch ('policy_check' vs 'hire decision') leaves the object under-specified. Adequate but with clear gaps given the absence of any output schema.

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

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

There is one parameter and schema description coverage is 100% ('Stored policy action id'), so the schema already fully documents it. The description only echoes the parameter name, adding no format, source, or lookup guidance beyond the schema, which is the baseline-3 case when the schema does the heavy lifting.

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 scoped resource ('one stored hire decision by actionId'), and the qualifier 'stored' distinguishes it from a live check such as the sibling aureon_check_policy. The only friction is that the resource is called a 'hire decision' while the tool name says 'policy_check', which creates mild ambiguity about what object is actually returned.

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 clause 'Does not send the hire and does not sign' implies this is the non-mutating read path versus a sibling that does send/sign, giving implied usage context. However, no alternative tool is named and there is no explicit when-to-use vs when-not-to-use statement, so the routing guidance must be inferred.

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

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

No annotations are provided, so the description carries the full burden. It implies a read of the current state, but says nothing about auth requirements, freshness/staleness, whether the book is cached, or what marks represent. A single noun phrase is thin disclosure for a tool with zero annotation coverage.

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

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

One short, front-loaded line with no filler. It is efficient, though the terseness borders on under-specification rather than optimal 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?

With no annotations and no output schema, the description must stand in as the only documentation. It names the data returned but not its shape or meaning (e.g., what 'marks' or 'weights' are computed from), leaving a modest gap for an agent deciding how to use the result.

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

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

The tool takes zero parameters, so there is nothing for the description to compensate for; baseline 4 applies. The mention of returned fields (positions, marks, weights) is a small value-add beyond the empty 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?

States a specific resource ('capital book') and verb-like action ('snapshot') plus the contents returned (positions, marks, weights). 'Current' implicitly distinguishes it from siblings such as aureon_get_portfolio_history and aureon_get_portfolio_watch_flow, though the differentiation 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?

No when-to-use guidance, no prerequisites, and no mention of alternatives like aureon_get_portfolio_history, aureon_sync_portfolio, or aureon_get_allocation_vs_target. The word 'current' hints that it is the live view, but nothing states that explicitly.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it states almost nothing beyond the resource: not whether the call is read-only, how far back the history reaches, how many entries are returned, or in what order. For a zero-parameter historical query these are the details that matter, and they are absent.

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

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

A single short clause with no filler and the key qualifier ('daily', 'stored') front-loaded. It is efficient, though arguably terse to the point of under-specification rather than tightly structured.

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

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

With no output schema and no annotations, the description is the only source of contract information, and it covers the resource and granularity but not the time range, result size, or ordering. For a simple zero-parameter read this is marginally adequate, but an agent cannot predict what it will receive.

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

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

The tool takes zero parameters, so the schema has nothing to explain and the baseline is 4. The description correctly introduces no parameter semantics because none exist.

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

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

The description names a specific resource and granularity ('daily portfolio totals') scoped to 'this wallet', and the word 'history' plus 'stored' implicitly separates it from the sibling aureon_get_portfolio, which returns the current portfolio. It stops short of explicitly naming that sibling or stating the contrast, so it is clear but not fully differentiated.

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

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

There is no when-to-use guidance, no mention of alternatives such as aureon_get_portfolio or aureon_get_health_history, and no stated conditions or prerequisites. The agent must infer usage entirely from the name and noun phrase.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Read' weakly implies a non-mutating call, but it says nothing about required auth, side effects, or the shape/scope of what is returned. For an unannotated tool this is a substantial gap.

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

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

A single compact sentence with no filler, and the resource and scope are front-loaded. It is efficient, though its brevity comes partly from under-specification rather than disciplined trimming.

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 annotations and no output schema, the description does no compensating work: it never explains the 'briefing' concept, what 'brief' and 'host' contribute, or when this flow is the right choice. An agent could invoke it, but not confidently or correctly in context.

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

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

Schema description coverage is 100%, so the schema already documents host, brief, and objectiveId. The description adds no extra meaning beyond what the schema supplies, which is exactly the baseline-3 case.

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 ('portfolio watch briefing') and scopes it to 'Automatic objectives'. It is clearer than a bare name, but 'Automatic objectives' is jargon that is not defined, and it does not differentiate from near-neighbors like aureon_get_objective_portfolio_flow or aureon_run_portfolio_watch_demo.

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

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

No when-to-use, when-not-to-use, or alternative is given. The scoping phrase 'for Automatic objectives' hints at applicability but leaves the agent to guess how this differs from the many other portfolio/watch/objective tools in the sibling 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?

With no annotations, the description carries the full behavioral burden. The word 'Read' weakly implies a read-only operation, but it says nothing about what the flow contains, whether it is static documentation or live state, auth requirements, or limits. This is a significant gap for an unannotated 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?

It is a single short sentence, which is well-sized, but the brevity reflects under-specification rather than disciplined conciseness. It is front-loaded only in the trivial sense that it is one phrase.

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 tool with no output schema and no annotations, the description should explain what the returned 'flow' actually is (steps, stages, status). It omits this entirely, leaving the agent unable to predict the response shape or confirm it is the right 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 100% and the schema fully explains the single executionId parameter ('Filter to one execution id (omit for five most recent)'). The description adds no parameter meaning beyond what the schema provides, so baseline 3 applies.

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

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

The phrase 'Read receipt → verification flow for execution receipts' names a resource (receipt verification flow) but largely restates the tool name rather than explaining what the tool actually returns or does. It does not distinguish itself from siblings such as aureon_validate_receipt or aureon_run_receipt_verification_demo. Purpose is only vaguely inferable.

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 when-to-use guidance, no prerequisites, and no mention of alternatives. With sibling tools like aureon_validate_receipt and aureon_run_receipt_verification_demo present, the agent gets no signal about which to pick. No exclusions or context 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 no annotations, the description carries the full behavioral burden and delivers almost nothing: no indication of auth requirements, error behavior for a missing/invalid id, or what "stored" distinguishes (e.g. confirmed vs. prepared reports). The word "stored" is the only behavioral hint, and it is undefined.

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 short, but brevity here comes from omission rather than precision — a four-word fragment with no verb. There is no front-loaded statement of action, so it reads as 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?

For a single-parameter, no-output-schema tool in a 60+ tool registry, the description should at minimum say it fetches one report by id and point to the list alternative. Neither is present, leaving the agent to guess at return shape and routing.

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

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

Schema description coverage is 100% for the single `id` parameter, so the baseline is 3. The description adds no format, type, or lookup semantics beyond what the schema already documents.

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 is a bare noun phrase, "One stored financial report," that restates the resource in the tool name without a verb or scope statement. It does weakly imply singular retrieval versus the sibling aureon_list_reports, but an agent gets no confirmation of what the tool actually 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?

No when-to-use guidance is given, and neither the natural alternative (aureon_list_reports) nor related lifecycle tools (aureon_prepare_report, aureon_confirm_report) are mentioned. The agent must infer usage entirely from the name.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It implies the plan is merely 'proposed' (non-mutating), but never states whether it is computed on demand or cached, whether any state changes, or what freshness/limits apply.

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 naming the resource first, then its content. No filler, though the terseness contributes to the gaps 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 and no annotations mean the description should explain the shape and nature of the returned plan, but it gives only a one-line gloss. For a plan-retrieval tool sitting among several restoration-related siblings, an agent lacks enough to confidently choose 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?

Single parameter with 100% schema description coverage, so the schema already documents objectiveId. The description adds no field-level meaning beyond what the schema provides, which is the baseline-3 case.

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

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

States a concrete resource (restore plan for an objective) and clarifies its content as 'proposed rebalance steps to return to policy', so the agent knows what it retrieves. It does not differentiate from near-neighbours like aureon_propose_restoration or aureon_get_drift_restore_flow, which keeps it short of a 5.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as aureon_propose_restoration (which presumably creates a plan) or aureon_restore_objective (which applies one). The agent must infer the read-only retrieval role from the name alone.

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

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

No annotations exist, so the description carries the full behavioral burden; it implies a read-only overview and discloses the content categories returned, which is genuinely useful with no output schema present. However, it says nothing about authentication requirements, permissions, rate limits, or whether the vault must exist, leaving meaningful behavioral gaps.

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 line with no filler; the purpose and the returned content are stated immediately without waste.

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

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

For a zero-parameter read tool with no output schema, the description usefully names the returned content, but it omits any distinction from aureon_get_vault_status/get_overview and gives no auth or precondition context. It is adequate but leaves 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?

The tool takes zero parameters, so there is nothing to disambiguate and the baseline is 4. The description adds no parameter detail, but none is needed.

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

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

The description gives a specific verb+resource (get vault) and enumerates what the overview contains (balances, tokens, deposit history), so the agent knows what the tool returns. It does not, however, differentiate this tool from close siblings like aureon_get_vault_status or aureon_get_overview, leaving the boundary ambiguous.

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 when-to-use guidance and no mention of alternatives, which is a real gap given siblings such as aureon_get_vault_status, aureon_get_overview, and the vault deposit/withdraw tools. The agent must infer the selection condition entirely on its own.

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

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

No annotations are provided, so the description carries the full burden. It mentions 'compact' output but says nothing about auth requirements, read-only nature, what field set is returned, or what 'funding status' concretely means, which is insufficient for a zero-annotation 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?

A single short fragment with the resource front-loaded and no filler. It is appropriately sized for a no-arg tool, though the trailing clause is more cryptic than informative.

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

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

With no output schema and no annotations, the description is the only source of information, and it leaves the return shape and meaning of 'funding status' undefined. For a state-introspection tool an agent needs to know what it receives; this is 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?

The tool takes zero parameters, so the schema has nothing to document and the baseline is 4. There are no parameter semantics for the description to add or omit.

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 the resource ('vault funding status') with a vague qualifier ('compact'), but does not distinguish it from the sibling aureon_get_vault or clarify what 'status' contains. The phrase 'ready state before restore' gestures at intent without committing to a specific verb or output.

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?

'ready state before restore' weakly implies a timing context, but no explicit when-to-use, when-not, or named alternative (e.g. aureon_get_restore_plan or aureon_get_vault) is given. An agent must infer the workflow position.

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

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

With no annotations, the description carries the disclosure burden. It communicates two useful traits: this is a read/list operation and it is scoped to the authenticated wallet, implying an auth requirement. It says nothing about pagination, ordering, or whether revoked/inactive keys are included in the result.

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, and the resource and scope appear before any qualifying clause. Nothing is wasted for a parameterless listing tool.

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

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

For a simple parameterless list tool with no output schema, the description covers what the tool does and its scope but omits the shape of the return (fields per key, pagination, empty-state behavior). Adequate but leaves the agent guessing about the response.

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

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

The tool takes zero parameters, and the schema (empty object) is fully consistent with that. Per the rubric, a zero-parameter tool has a baseline of 4; there is no parameter semantics to clarify further.

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 (List) and resource (SDK API keys) and scopes it to the authenticated wallet, which cleanly separates it from siblings like aureon_create_api_key, aureon_revoke_api_key, and aureon_toggle_api_key. It does not explicitly name those alternatives, but the verb makes the read-only listing intent 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?

There is no guidance on when to call this versus the sibling key-management tools (create/revoke/toggle). The phrase 'for the authenticated wallet' implies a prerequisite (an authenticated wallet session) but no explicit when/when-not conditions 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 no annotations provided, the description carries the full burden of behavioral disclosure, yet it says nothing about read-only safety, result ordering, pagination, or result volume. For a list endpoint that could return an unbounded collection, the omission of ordering/pagination behavior is a real gap.

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

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

It is a single short, front-loaded fragment with zero waste, but it is under-specified rather than merely concise — no verb, no object framing, no clause telling the agent how to call it. Brevity here costs information rather than saving it.

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

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

For a one-parameter list tool with no output schema and no annotations, the description should at minimum state that it returns a collection and what unfiltered calls return. Neither is present, leaving the agent unable to predict the response shape or scope.

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 single objectiveId parameter is documented as 'Limit to one objective', so the schema already carries the semantics. The description adds no filtering syntax or default-scope detail beyond that, which is the expected baseline of 3.

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

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

The description identifies the resource (decision records) and the triggering action types (set, change, pause, resume), but never states the verb explicitly or that it returns a collection. It also does not distinguish this list tool from the sibling aureon_get_decision, so an agent must infer the list-vs-single semantics from the name alone.

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 when-to-use guidance, no indication of the default scope when objectiveId is omitted, and no reference to the closely related aureon_get_decision sibling. The agent is left to guess whether this is the right entry point for retrieving decision history.

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

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

No annotations are provided, so the description carries the full behavioral burden. It gestures at returned fields (settlement, verifiedOnChain, settlementRecord, explorerUrl, registryRef), which is genuinely useful, but says nothing about read-only semantics, ordering, pagination/limits, or what 'recent' means in practice.

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 field list is compact. It is efficient, though the em-dash field dump reads more like a return-value sketch than a 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 no annotations and no output schema, the description should explain the operation's scope and return behavior. Instead it leaves ordering, limits, filtering, and read-only status unstated, which is thin for a listing tool in a crowded sibling namespace.

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

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

Schema description coverage is 100% for the single optional objectiveId filter, so the schema already explains its meaning. The description adds no filtering detail beyond the schema, so the baseline 3 applies.

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

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

The phrase 'Recent execution receipts' conveys the resource (execution receipts) but never states the verb explicitly — the agent must infer 'list' from the name. It also fails to distinguish this tool from close siblings like aureon_list_settlements, aureon_get_execution_settlement, and aureon_validate_receipt, which plausibly surface overlapping data.

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

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

There is no guidance on when to use this versus aureon_list_settlements, aureon_get_execution_settlement, or aureon_validate_receipt, nor any mention of prerequisites or scope. The only hint is the word 'Recent', which is not an explicit condition.

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

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

With no annotations at all, the description carries the full burden of behavioral disclosure. It implies a read-only enumeration, but never states that the call is side-effect free, whether the preset list is static or account-specific, or whether any auth is required. For a zero-annotation tool this is a real gap.

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

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

Five words with no filler, which is appropriately tight for a trivial list endpoint. However, the brevity crosses into under-specification: it is a label rather than a sentence, so it is concise but not informative.

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

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

There is no output schema, so the description should at minimum hint at what a preset looks like or how the returned identifiers feed into aureon_apply_market_event. Neither is present, and with no annotations the safety and auth profile is also absent. For such a simple tool the bar is low, but the definition still leaves the agent without a usable next step.

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

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

The tool takes no parameters, so there is nothing for the description to disambiguate; the baseline of 4 for a 0-parameter schema applies. No parameter information is missing because none exists.

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 phrase 'Available market event simulation presets' identifies the resource (presets) and its domain (market event simulation), so an agent can guess this enumerates them. But it is a bare noun fragment with no verb and no differentiation from siblings such as aureon_apply_market_event, which consumes exactly these presets. Purpose is inferable rather than stated.

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 when-to-use guidance and no mention of the obvious companion tool aureon_apply_market_event, which is presumably why an agent would fetch these presets in the first place. The agent is left to infer the workflow entirely from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether authentication is required, whether the list is paginated or bounded, or what the return shape looks like — all meaningful gaps for a tool with zero structured coverage.

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

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

A single short sentence with no filler and the action front-loaded. It is efficient, though arguably under-specified rather than optimally concise.

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

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

For a zero-parameter list tool this is minimally adequate, but with no annotations and no output schema the description leaves the agent without any hint about auth requirements, result size, or return shape. It stops at naming the operation and does not round out the picture.

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

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

The tool takes no parameters, so there is nothing for the description to disambiguate; the baseline for a zero-parameter tool is 4. Nothing in the description contradicts or mischaracterizes the empty 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?

States a specific verb ('List') and resource ('Financial Compass Objectives'), and the word 'all' implies an unfiltered collection operation. However, it never differentiates itself from the sibling aureon_get_objective or explains what a 'Financial Compass Objective' is, so sibling disambiguation is left to the reader.

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

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

No when-to-use guidance, no prerequisites, and no mention of the alternative aureon_get_objective for retrieving a single objective. The agent must infer usage purely from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the implicit read-only nature of 'stored ... reports'. It says nothing about ordering, pagination, filtering, wallet scoping requirements, or whether reports can be empty.

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

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

A single short phrase with zero filler, front-loaded with the resource. It is appropriately sized in form, though the sparseness is an under-specification problem rather than a merit.

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

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

For a no-parameter list tool with no output schema and no annotations, the description must at minimum convey what a 'report' contains, how results are ordered or bounded, and how it differs from aureon_get_report. None of that is present, so an agent cannot call this confidently alongside its siblings.

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

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

The tool takes zero parameters, so per the baseline there is nothing for the description to disambiguate. The scope phrase 'for this wallet' is the only parameter-like context and the implicit wallet binding is at least hinted at.

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 is a bare noun phrase, 'Stored financial reports for this wallet', with no verb indicating the operation (list vs. get vs. prepare). It essentially restates the tool name aureon_list_reports with a scope qualifier, and gives no signal to distinguish it from aureon_get_report, aureon_prepare_report, or aureon_confirm_report.

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 statement of when to call this tool, no prerequisites, and no mention of alternatives. With four sibling report tools plus aureon_list_timeline and aureon_list_decisions, the absence of any routing guidance leaves the agent to guess.

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

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

With no annotations, the description carries full burden and does disclose a genuinely non-obvious trait: results 'May include orphans (observed vault Rebalanced events not yet bound to an execution)'. However it omits read-only confirmation, pagination, and permission requirements, leaving key behavioral context unstated.

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 purpose followed by the orphan caveat and the usage tip. 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?

Complete for a read-only list tool with full parameter coverage and no output schema: it covers purpose, filter, and an important result caveat. Only pagination/result-shape details are absent, which is minor here.

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% on the single objectiveId parameter, so the schema already documents it. The description's 'Optional objectiveId filter' merely reinforces what the schema says without adding syntax or format detail—baseline 3.

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

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

States a specific verb and resource ('Lists settlement records') with scope ('for the authenticated wallet'). It clearly distinguishes itself from aureon_get_execution_settlement by being the plural list, but never names that sibling 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?

Provides an actionable tip ('Read status and executionId before claiming proof') and notes the objectiveId filter is optional, but gives no explicit when-to-use vs when-to-use-an-alternative guidance. Usage is implied rather than stated.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It does disclose the read-only, paginated nature of the tool and the content categories returned, but says nothing about ordering (e.g., newest-first), authentication requirements, or result shape. It adds some context beyond the name but leaves notable gaps.

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

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

Two short sentences, front-loaded with what the timeline contains and then the pagination hint. Efficient, though the second sentence overlaps with what the schema already states about 'before' and 'limit'.

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

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

For a simple 3-parameter, no-annotation, no-output-schema read tool, the description covers content and pagination adequately but omits ordering and the shape of an event record. It is viable but leaves the agent inferring return structure.

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

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

Schema description coverage is 100%, so all three parameters (limit, before, objectiveId) are already documented in the schema. The description's pagination note largely restates the 'before' cursor semantics without adding format or edge-case detail, so the baseline 3 applies.

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

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

The description gives a clear verb+resource ('Timeline of events') and enumerates what populates it (objective changes, executions, health transitions), so an agent knows what it returns. It does not, however, distinguish this from overlapping siblings such as aureon_list_executions, aureon_list_decisions, or aureon_get_audit_trail.

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 usage instruction is pagination mechanics ('Pass before ... and limit to read the next page'), which is implied usage rather than selection guidance. There is no statement of when to prefer this tool over the executions/decisions/audit-trail siblings, and no exclusions.

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

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

With no annotations, the description carries the full burden. It discloses two concrete effects (session revocation plus clearing the in-process token), which is genuine behavioral detail, but omits whether the call is idempotent, what happens if the token is already invalid, and what errors may surface.

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 primary action (revoke) leads and the side effect (clear in-process token) follows. 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 no-parameter, no-output-schema tool the description covers the core action adequately, but with zero annotations it should say more about post-call state (e.g., subsequent authenticated calls will fail, token no longer usable) to be fully actionable.

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?

Zero parameters, so there are no parameter semantics to explain; the baseline of 4 applies. Nothing is misrepresented or omitted at the parameter level.

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 (Revoke) and resource (current Bearer session) plus a secondary effect (clear in-process token). The 'Bearer session' framing distinguishes it from aureon_revoke_api_key, though the description doesn't explicitly name that sibling.

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

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

Logout usage is implied — an agent can infer it should be called to end a session — but there is no explicit when-to-use statement, no note on prerequisites (must be authenticated), and no pointer to sibling auth tools like aureon_dev_login for re-authenticating.

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

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

With no annotations, the description carries the full burden, but it does disclose a real behavioral trait: identity is derived from either an issued API key or the current Bearer session. It does not say what happens when neither is present (error vs. empty), whether the call is read-only, or whether it has side effects on the session.

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 identifying condition (API key vs. Bearer session) comes immediately. Nothing could be removed without losing 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?

There is no output schema and no annotations, so the description must carry the return contract; 'the wallet' is left ambiguous (address string vs. wallet object vs. portfolio summary). For a zero-parameter identity tool this is close to adequate, but an agent cannot predict the response shape or the unauthenticated case.

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

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

The tool takes zero parameters, so the schema provides nothing to interpret and the baseline is 4. No parameter semantics are needed beyond the auth-context note already given.

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 ('Return') and resource ('the wallet bound to the issued API key or current Bearer session'), which is meaningfully more specific than a tautology. It implicitly distinguishes itself from identity-adjacent siblings like aureon_verify_wallet and aureon_get_auth_nonce, but never names or contrasts them explicitly.

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

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

Usage is only implied: an agent can infer this resolves 'who am I' for the current session. There is no explicit when-to-use, no prerequisites, and no guidance on choosing it over aureon_verify_wallet, aureon_get_auth_nonce, or aureon_dev_login.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say whether pausing is reversible, what happens to in-flight evaluations, whether the decision is recorded (the 'reason' param hints at a decision record), or what authorization is required for this mutation.

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 zero waste, though it is terse to the point of under-specification rather than optimally concise.

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 tool with no annotations and no output schema, the description is too thin. It omits reversibility, side effects, and the fact that a decision record is created, leaving the agent without enough context 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 description coverage is 100%, so both parameters (objectiveId, reason) are already documented in the schema. The description adds no further parameter meaning; 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 (pause) and resource (continuous evaluation for an objective), which clearly separates it from aureon_resume_objective by antonym. It doesn't explicitly name the sibling or clarify what 'continuous evaluation' encompasses, but the core 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?

No when-to-use, when-not-to-use, or prerequisite information. The pairing with aureon_resume_objective is inferable only from the tool name, not stated in the description.

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

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

No annotations are provided, so the description carries the full burden. It conveys the essential trait  a non-mutating connectivity check  but says nothing about auth requirements, rate limits, or what a failed probe looks like. For a zero-parameter probe the burden is small, so this is adequate but thin.

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 zero filler; the purpose is stated before the elaboration. Nothing redundant or padded.

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

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

With no output schema, the description should ideally indicate what a successful probe returns (status payload, version, latency). It only asserts that connectivity is confirmed, leaving the response shape unspecified. Otherwise complete for a trivial probe.

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

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

The tool takes no parameters, so no parameter semantics are needed; the baseline for a zero-parameter tool is 4. The description correctly implies no input is required.

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

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

States a specific verb-and-resource (health probe / confirms API connectivity), so an agent knows exactly what it validates. It does not differentiate itself from the sibling aureon_get_health, which is a plausible overlap risk.

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 health probe implies the usage context (liveness/connectivity check) without spelling out when to prefer it over aureon_get_health, aureon_registry_status, or aureon_get_vault_status. No explicit when-to-use or when-not-to-use guidance is given.

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

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

No annotations are present, so the description carries the full burden. It usefully discloses the two-phase nature (this tool only prepares signed calldata; the host wallet must broadcast), which is meaningful behavioral context. But it omits auth/permission requirements, idempotency, reuse/expiry of prepared calldata, and failure 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?

Two short sentences, zero filler, and the core action ('Prepares wallet-signed calldata') is front-loaded before the follow-up step. 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?

With no annotations and no output schema, the description should do more: it never describes what the prepared calldata payload contains or how to consume it. It does cover the crucial two-step flow, but leaves gaps for a mutation-oriented prepare 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?

There is a single parameter with 100% schema description coverage, so the schema already documents 'objectiveId'. The description adds no format, constraint, or validity detail beyond what the schema provides, matching the baseline 3 for high coverage.

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

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

States a specific verb ('Prepares wallet-signed calldata') and resource ('register an objective on ObjectiveRegistry'), so the agent knows this is a prepare step, not the registration itself. It hints at the confirm sibling via 'then call confirm via SDK' but never names aureon_confirm_objective_registry 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?

It lays out the follow-up workflow (host wallet broadcasts the tx, then confirm via SDK), which is real usage context. However, it gives no explicit when-to-use vs alternatives or prerequisites (e.g. whether the objective must exist, or when to prefer this over other prepare tools).

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

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

With no annotations, the description carries full burden. It usefully discloses a real behavioral trait — no broadcast occurs, so nothing irreversible happens — and that a signing message is returned. But it omits auth/permission requirements and what state (if any) is mutated on the objective.

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

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

Two tight sentences with zero waste; the core action is front-loaded and the crucial non-broadcast caveat follows immediately.

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

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

With no output schema, the description correctly states the return ('the message to sign') and confirms the non-broadcast semantics. For a one-parameter prepare step this is nearly complete, missing only prerequisite/auth context.

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 objectiveId parameter, and its schema description ('Objective id') is minimal. The description adds no syntax, format, or sourcing detail for the id, so 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 ('Build') and resource ('financial report') and adds the scope 'from stored rows'. Implies the prepare/confirm two-step pattern via 'return the message to sign', though it never names the sibling aureon_confirm_report outright.

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?

'Does not broadcast' implies the caller must proceed to sign and confirm, so the workflow role is inferable. However, there is no explicit when-to-use vs aureon_confirm_report/aureon_list_reports guidance, leaving the agent to infer the sequencing.

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

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

No annotations are provided, so the description carries the full burden, and it does well: it discloses that only calldata is returned, that signing/broadcasting is the caller's responsibility, and that an API key alone cannot move funds — a key safety boundary. It leaves out failure modes, validation behavior, and whether any server-side state is created, which keeps it short of a 5.

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

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

Three short sentences, zero filler, with the core action front-loaded and the critical signing caveat immediately after. Every sentence carries distinct information.

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

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

With no output schema and no annotations, the description usefully covers both what is produced (calldata) and the required follow-up (external signing), which is the essential context for a prepare-type tool. It is only slightly thin on preconditions such as authentication requirements or error conditions.

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

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

Schema description coverage is 100%, so both parameters (symbol, amount) are already documented in the schema, including the ETH/allowlisted-ERC-20 constraint. The description adds no format or constraint detail beyond that, so the baseline 3 is appropriate.

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

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

States a specific verb+resource: 'Prepare unsigned vault deposit steps.' Combined with 'Returns calldata only,' an agent immediately knows this builds a deposit transaction rather than executing one. It does not explicitly contrast with the sibling aureon_prepare_vault_withdraw, but the deposit framing makes the distinction reasonably clear.

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 its place in a workflow ('the host must sign/broadcast with a wallet private key'), which tells the agent this is a pre-signing step. However, it never states when to use this versus alternatives like aureon_prepare_vault_withdraw, nor any prerequisite conditions beyond the signing note.

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

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

With no annotations, the description carries the full burden and does well: it states the tool produces unsigned calldata only, that the host must sign/broadcast, and that an API key alone cannot move funds. That discloses non-mutating behavior and a security boundary, though it omits required permissions and any chain/network 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 tight clauses, front-loaded with the operation and followed by the two critical constraints. Zero 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 two-parameter prepare tool with no output schema, the description covers the key contract: calldata-only output, host-side signing, no fund movement. It leaves minor gaps on required auth scopes and what to do with the returned calldata, but nothing essential is missing.

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

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

Schema coverage is 100%, so the schema already documents both amount and symbol. The description adds no syntax, formatting, or default details beyond the schema's note that symbol defaults to WETH, so 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: 'Prepare unsigned vault withdraw steps.' An agent can tell the action apart from its deposit sibling, though the description never names aureon_prepare_vault_deposit or any alternative explicitly.

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

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

Usage is implied by the verb ('prepare... withdraw'), but there is no statement of when to prefer this over alternatives, no prerequisites, and no mention of a confirm/broadcast follow-up step an agent would need to chain after this prepares calldata.

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

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

With no annotations provided, the description carries the full burden and does disclose meaningful traits: it is unsigned, does not sign or broadcast, requires both objectives to be 'manual', and returns 'to, data, and value for each step'. It omits auth requirements, whether any state is persisted, and any rate/limit behavior, so it is partial rather than complete.

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 front-loads the core purpose, and most sentences carry information. The closing sentence about the profit slice is confusing enough that it weakens rather than earns its place, pulling this below a clean 4.

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 annotations and no output schema, the description must supply the behavioral and safety context itself. It gives a partial return shape and a precondition but omits authorization requirements and the relationship to the confirm step, which is critical for a financial restoration flow.

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%, so both parameters are already documented, making 3 the baseline. The description adds one semantic constraint ('Both objectives must be manual') that is not in the schema, but it does not clarify the weightBound ceiling/floor relationship beyond what the schema states.

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

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

The verb+resource ('Unsigned restoration from vault balances') is identifiable, and 'Does not sign or broadcast' implicitly separates it from the confirm_restoration sibling. However, 'sleeve cap' and 'stable reserve floor' are opaque domain jargon that the agent cannot decode, and the tool is never distinguished by name from aureon_get_restore_plan or aureon_confirm_restoration.

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 a precondition ('Both objectives must be manual') but no when-to-use, when-not-to-use, or named alternatives among the many restoration siblings (get_restore_plan, confirm_restoration, restore_objective). The final sentence ('A full return to the sleeve cap is not the profit slice') hints at a constraint but is too cryptic to guide selection.

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

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

With no annotations, the description carries the full behavioral burden and does not meet it. 'Refresh ... from live data' implies an external fetch and a state mutation, but the description never says whether portfolio/objective state is overwritten, whether this is idempotent, whether it is costly or rate-limited, or what permissions it requires.

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, and the two effects (refresh marks, re-evaluate objectives) are stated in a logical order. It is efficient, though arguably too terse for the behavioral weight it must carry.

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 annotations, no output schema, and no description of return values or side effects leave the agent unable to predict the result of a call that appears to mutate live portfolio state. For a zero-parameter, presumably state-changing maintenance tool, the description is 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?

The schema declares zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. No parameter information is missing.

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

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

The description pairs a specific verb ('refresh') with concrete resources ('portfolio marks', 'objectives'), so an agent can tell what the call accomplishes. It does not, however, differentiate itself from close siblings such as aureon_sync_portfolio or aureon_apply_market_event, which plausibly touch the same state.

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

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

There is no statement of when to use this tool versus aureon_sync_portfolio, aureon_run_portfolio_watch_demo, or the objective-listing tools. The agent must guess whether this is a periodic maintenance call or a prerequisite for other operations.

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

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

With no annotations, the description carries the full burden, and it does disclose one useful behavioral fact: the contract address is only present 'when configured', implying an optional/absent value. It does not state whether authentication is required, whether it errors on an unconfigured network, or what the status field contains.

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

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

A single sentence with zero filler, front-loading the action and resource before the qualifier about the active network. Nothing needs trimming and nothing essential is buried.

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

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

For a zero-parameter, read-only status tool with no output schema, the description is nearly sufficient, naming the main returned artifact (contract address). It stops short of describing the other status values or clarifying the relationship to the registry-read sibling.

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

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

The tool takes zero parameters, so there is nothing further to document and the baseline is 4. The description correctly avoids inventing parameter discussion.

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

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

The description gives a specific verb ('Returns'), a specific resource ('ObjectiveRegistry deployment status'), and a scope ('for the active network'), so the operation is unambiguous. However, it never distinguishes itself from the closely named sibling aureon_get_objective_registry, leaving the agent to guess which registry-related read 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 when-to-use or when-not-to-use guidance, and no mention of alternatives despite siblings like aureon_get_objective_registry, aureon_prepare_objective_registry, and aureon_confirm_objective_registry. The agent must infer the usage context entirely.

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

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

With no annotations, the description carries the full burden. It does disclose non-obvious behavioral traits: the operation is not always vault-backed, 'staged is never on-chain', and 'vault without verifiedOnChain is submitted, not proven', plus that it returns an ExecutionReceipt. However it omits permission/auth requirements, reversibility, and what side effects occur on-chain, so it is informative but incomplete.

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 short and front-loads the purpose before the settlement semantics. It is somewhat telegraphic and jargon-heavy ('staged', 'submitted, not proven'), which slightly hurts readability, 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 an execution tool with no annotations and no output schema, the description should explain the return and side effects more fully. It names ExecutionReceipt but does not describe its contents, and it leaves permission and on-chain effect details 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?

There is a single parameter with 100% schema description coverage, so the schema already documents objectiveId. The description adds no format, ID source, or constraint information beyond what the schema provides, making the baseline 3 appropriate.

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

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

The description states a specific verb+resource ('Run restorative execution for an objective') and adds a meaningful scope qualifier ('outside policy'). It is clear what the tool does, but it does not explicitly distinguish itself from close siblings such as aureon_run_execution, aureon_confirm_restoration, or aureon_propose_restoration.

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 routing to the sibling restoration tools (propose/confirm/get_restore_plan) that an agent would need to sequence correctly. The 'outside policy' qualifier implies a context but never states the precondition for choosing this tool over aureon_run_execution.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Resume evaluation' implies a state mutation, but the description says nothing about what changes, whether it is reversible, what permissions are needed, or how it interacts with the paired pause 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?

A single front-loaded sentence with zero filler. It is efficient, though the extreme brevity leaves little room to earn additional value.

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

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

For a state-mutating tool with no annotations and no output schema, the description omits what happens on success, whether the resume is reversible, and how it relates to the pause/restore siblings. An agent would need to guess at the surrounding workflow.

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

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

Schema description coverage is 100%, so both parameters are documented in the schema; baseline is 3. The description adds only context that the objectiveId should reference a paused objective, no syntax or format detail beyond that.

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 (resume) and resource (objective) plus the precondition state (paused). It is clearly understandable on its own, though it does not differentiate itself from nearby siblings such as aureon_pause_objective, aureon_restore_objective, or aureon_update_objective.

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

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

The phrase 'for a paused objective' implies the trigger condition, so usage is inferable. However, there is no explicit guidance on when to choose this over aureon_restore_objective or aureon_update_objective, and no exclusions or prerequisites are stated.

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

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

No annotations are provided, so the description carries the full burden. The parenthetical 'delete' usefully signals this is destructive rather than a reversible disable, but it says nothing about irreversibility, required auth/permissions, or what happens to the key afterward.

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?

Six words, front-loaded with the verb and resource, with zero filler. It is optimally scannable, though the extreme brevity is arguably under-specification rather than genuine 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?

For a destructive, unannotated, single-parameter tool with no output schema, the description is too thin. It omits whether revocation is permanent, whether it can be undone, and any warning that the operation removes SDK access.

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?

Single parameter with 100% schema description coverage; the schema already documents keyId as 'API key ID'. The description adds no format or sourcing detail beyond the schema, which is the expected 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 (revoke/delete) and resource (SDK API key), and the parenthetical clarifies the operation's destructive nature. It is clearly distinguishable from aureon_create_api_key and aureon_list_api_keys, though it doesn't explicitly name the nearest sibling, aureon_toggle_api_key.

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

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

No guidance on when to revoke versus when to use aureon_toggle_api_key (which presumably disables rather than deletes), and no prerequisites or confirmation context. The agent must infer the use case from the name alone.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose real side effects by naming the sequence (seeds state, deliberately breaks a rule, then restores it), which tells the agent this mutates data rather than merely observes. However, it says nothing about reversibility, whether it touches shared/production state, auth requirements, or idempotency — all material for a demo that writes 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?

A single line with zero waste, front-loading the verb and the demo name before the step detail. The arrow notation compresses the sequence efficiently.

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

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

For a zero-param, zero-annotation tool with no output schema, the description covers what the tool does operationally but omits what the agent gets back and any safety/auth framing. It is adequate to trigger the call, but thin for understanding consequences.

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

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

The tool takes zero parameters, so there is no parameter semantics for the description to add. Baseline 4 applies; the parenthetical steps describe internal behavior rather than inputs.

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

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

Specific verb ('Run') plus the named demo and its three internal steps (seed book, break rule, manual restore) make the action unambiguous. It is implicitly distinguishable from the 'get_*_flow' siblings, but the description never names aureon_get_drift_restore_flow, so the contrast is left to the reader.

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

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

Usage is only implied by the word 'demo' — an agent can infer this is a scripted end-to-end demo rather than a production operation. There is no explicit statement of when to prefer this over aureon_get_drift_restore_flow (which presumably describes the same flow without executing it) and no prerequisites.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose valuable state semantics (staged = never on-chain; vault + verifiedOnChain = chain-observed; vault without verified = submitted but not yet observed), which is genuinely useful given there is no output schema. However, it omits whether this is a mutation, what authorization or policy constraints apply, and any side-effect or idempotency 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?

Two sentences, front-loaded with the action statement. The second sentence is dense but earns its place by explaining receipt fields that would otherwise be undocumented, though the phrasing is somewhat telegraphic.

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