invinoveritas

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

Annotations already mark this as read-only and non-destructive. The description adds meaningful behavioral context beyond that: it returns a score, grade, ranked fixes, and a signed proof, and it emphasizes that every result re-derives from a fresh public fetch, which affects how an agent should interpret the output.

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 well-structured and front-loaded with the core verb and resource. Each sentence adds value: scope, checked items, return values, verification guarantee, and a docs link. There is no fluff or repetition of the schema.

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

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

For a single-parameter, read-only audit tool with no output schema, the description is complete. It explains what will happen, what the result looks like, and the guarantee that results are reproducible from public fetches. No critical missing context is apparent.

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 only one parameter, url, and its schema description already specifies that it must be a public HTTP(S) agent endpoint/site URL. The tool description does not add new parameter-level information, but with 100% schema description coverage, this is an acceptable baseline.

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

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

The description clearly identifies the tool's action: auditing a public agent or API URL for verifiability. It enumerates specific checked artifacts (llms.txt, MCP card, robots, sitemap, handshake endpoints, signed proofs) and the concrete output (score, grade, ranked fixes, signed proof), which distinguishes it from generic siblings like validate or verify_proof.

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 makes the intended context clear: public agent/API URLs only, with all results derived from public fetches. It does not explicitly compare against sibling tools or state when not to use it, but the public-only constraint and audit-specific focus provide sufficient guidance for most cases.

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

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

Beyond the annotations, the description discloses that the entry is permanent and signed, that the tool cannot change the registry measurement, and that it only works for currently certified verifiers. This adds meaningful behavioral context beyond the readOnlyHint, idempotentHint, and destructiveHint annotations.

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

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

The description is three sentences with no filler. It front-loads the core action, then adds the key limitations and a documentation link. Every sentence contributes useful 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?

The description covers the purpose, the permanent signed nature, the inability to change the measurement, and the certified-only precondition. A small gap is that it does not describe the return value or explicitly contrast with ledger_submit, but the documentation link and annotations fill most remaining 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%, and the schema already documents both parameters, including the exact-name requirement and the certified:true precondition. The description reinforces this by mentioning the registry and certification status, but it does not add substantial parameter-level meaning beyond the schema.

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

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

The description opens with a specific verb ('Publishes') and resource ('verifier's current conformance grade from the public registry') and clearly distinguishes this from other ledger operations by stating it cannot change the existing measurement. It also adds the certified-only precondition, making the tool's scope unambiguous.

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

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

The description clearly states when the tool applies: only for a verifier currently listed as certified, and it records the registry's existing measurement rather than creating or altering it. It does not explicitly name an alternative such as ledger_submit for new ledger entries, but the constraints are clear enough for an agent to select this tool appropriately.

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

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

Beyond the readOnlyHint and idempotentHint annotations, the description reveals that entries are signed Nostr events whose integrity can be recomputed, and that they are append-only and Bitcoin-timestamped, implying immutability. It also states the access model, free and no sign-in, which is useful for an agent deciding whether to call. No contradiction with annotations.

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

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

Four sentences, each earning its place: purpose, integrity model, usage, and access/documentation. The most decision-relevant information is front-loaded in the first sentence, and the docs link is a compact pointer rather than bloat.

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

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

For a single-optional-parameter read tool with annotations already covering safety and idempotence, the description covers purpose, data model, behavior, access, and documentation. The only omission is a concrete description of the response shape for the index or an entry, but that is partially mitigated by the explicit usage instructions and docs link.

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 input schema already fully documents the optional entry parameter with an example and the omit-for-index behavior, so the baseline is 3. The description restates this behavior rather than adding new parameter-level semantics. No additional syntax or format details are introduced.

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?

Opens with a specific verb and resource: 'Reads invinoveritas's public track record of signed verdicts,' which immediately sets it apart from write/verify siblings like ledger_submit and verify_proof. The addition of 'including ones that turned out wrong' narrows the scope and reinforces that this is an audit/read tool. Clear and unambiguous purpose.

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

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

Provides concrete invocation context: no arguments yields the index, passing entry reads a specific record, and access is free with no sign-in. It does not explicitly name alternatives or state when-not-to-use, but the read-only framing makes the appropriate use clear for an agent.

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?

The description adds meaningful behavioral disclosure beyond the annotations: publication is 'immediate and permanent', broadcast to Nostr relays, Bitcoin-timestamped, and restricted to 'genuine invinoveritas-signed proofs'. With readOnlyHint=false, idempotentHint=false, and destructiveHint=false already provided, this description usefully explains the irreversible, external side-effects of the 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?

The description is compact and front-loaded: the core action appears in the first sentence, followed by critical permanence constraints and acceptance criteria. Every sentence carries information relevant to calling the tool correctly, and the docs URL is a lightweight addition rather than noise.

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

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

For a tool with no output schema, the description covers the important context: source input (signed review proof), destination (ledger/Nostr), permanence, and validity requirements. It does not describe the exact return shape or failure modes, but the docs link and clear input constraints make this adequate for safe invocation of an irreversible publish action.

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 well, including that event must be the exact proof.event object from a prior /review(sign=true) call. The description reinforces this by saying the input must be one of the user's own signed proofs, but it does not add substantial new meaning for either parameter beyond the schema.

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

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

The description names a specific verb and resource ('Publishes... on the invinoveritas ledger') and scopes the input precisely to 'one of your own signed review proofs (from review with sign=true)'. This clearly distinguishes it from siblings like ledger, review, and verify_proof by specifying exactly which prior output it consumes and what permanent public action it performs.

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 establishes the correct triggering context: it should be used after a review call with sign=true, and only on the exact proof.event returned there. It does not explicitly name alternatives or exclusions (e.g., 'use ledger to read entries'), but the conditional source is clear enough for most agents to avoid misuse.

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

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

Annotations only declare the safe-read profile (readOnlyHint=true, destructiveHint=false). The description adds substantial context beyond that: the verdict vocabulary (approve/approve_with_concerns/reject) with confidence score and severity-ranked issues, the meaning of sign=true and the signed-proof guarantee, the reversibility_gate / epistemic_basis response semantics, and the explicit caveat that the verdict is a reasoned second opinion, not a guarantee.

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

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

Front-loads the core purpose in the first clause, then layers return shape, signing behavior, and caveats. Every sentence contributes (return contract, proof linkage, disclaimers). Slightly dense but appropriate for a tool with this much behavioral surface.

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 17-parameter tool with nested objects and no output schema, the description supplies the missing response vocabulary (approve/reject/confidence/severity/fixes) and the sign→verify_proof relationship, plus honest limits. It gives an agent enough to call it and interpret the result correctly.

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

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

Schema coverage is 100%, so the schema carries the per-parameter burden (baseline 3). The description modestly adds value by tying sign=true to verify_proof and illustrating usage. Since structured fields already document all 17 params thoroughly, the description does not need to compensate further, and it introduces no conflicting semantics.

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 ('Independent verdict on a proposed action before it is taken') and enumerates exactly what can be reviewed — diff, shell command, deployment plan, config change, agent output, transaction. This clearly distinguishes it from siblings like verify_proof (used after the fact) and ledger/witness.

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 timing context ('before it is taken') and routes to the alternative for the after-the-fact case ('check later with verify_proof'). It also encodes per-artifact_type usage conditions (e.g. onchain_action 'BEFORE you sign it'). No explicit when-not-to-use exclusions, but the routing guidance is strong.

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

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

Annotations already mark the tool as read-only and non-destructive; the description adds meaningful behavioral context by detailing the statistical methods (Deflated Sharpe Ratio, permutation test, purged-fold decay) and stating that inputs are not retained beyond a redacted audit hash. No contradiction with annotations.

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

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

The description is compact and front-loaded: purpose first, then method, then data-retention behavior, then docs link. Every sentence contributes information without 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 complex statistical tool with no output schema, the description explains the main return classification and the methodology, and the schema covers parameter details. It could be more explicit about the full response shape, but an agent has enough to select and invoke the tool correctly.

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

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

With 75% schema coverage, the schema covers most parameters, and the description adds semantic context for several: 'realized returns (or trade rows)' clarifies returns/trades, 'number of variants tried' explains n_trials, and 'purged folds' and 'sign-flip permutation test' give meaning to k_folds and n_perms.

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

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

The description clearly states a specific purpose: statistically reality-checking a backtest from realized returns or trade rows, and it names the output categories (likely_real / borderline / overfit_or_noise). It does not explicitly distinguish this from sibling tools like review or verify_proof, though 'not the strategy itself' narrows the scope.

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

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

The description gives clear context for when to use the tool: when you have realized returns or trade rows from a backtest and want an overfitting reality-check. It includes an exclusion ('not the strategy itself') but does not name alternative tools or provide explicit when-not-to-use guidance.

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

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

Annotations already establish read-only, idempotent, and non-destructive behavior, so the description only needs to add context beyond that. It adds useful behavioral detail: verification is done without trusting the presenter, the tool fetches durably-stored events when given an id, and it is free with no sign-in. No contradiction with annotations.

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

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

The description is compact yet information-dense, starting with the core verification behavior, then optional parameters, accepted inputs, return shape, and access requirements. Every sentence earns its place and the docs link is a useful fallback without padding.

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

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

For a read-only verification tool with a rich input schema, the description covers the purpose, inputs, return shape, and cost. It does not detail the structure of the checks field or error behavior, but the return shape {valid, checks, proof_payload} plus the docs link provides adequate grounding without an output schema.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters thoroughly. The description adds a small amount of semantic context by explaining that expect_artifact_hash confirms the proof covers the received content and by summarizing the two main input modes, but it does not significantly go beyond the schema.

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

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

The description opens with a specific verb and resource — 'Checks a signed invinoveritas proof' — and then enumerates the exact verification steps: recomputing the event id, checking the Schnorr signature, and confirming the signing key. This clearly distinguishes verify_proof from siblings like witness or validate by describing what makes this tool unique.

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

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

It provides clear input alternatives ('Accepts the full event, or an event_id to look up') and explains when to use the optional expect_artifact_hash parameter to confirm content coverage. It does not explicitly name sibling tools or state when not to use it, but the usage context is strongly implied by the precise verification 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?

Annotations only provide negative hints (not read-only, not idempotent, not destructive). The description adds key behavioral details: the tool creates a signed timestamp, leaves the claim unmodified and unjudged, and records the source as self-declared. It stops short of specifying persistence or rate limits, but covers the core 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 compact and front-loaded, using a concrete example to explain the non-judgment nuance. Every sentence serves a purpose – core action, source caveat, verification route, and docs link – with no 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 two-parameter tool with no output schema, the description covers the purpose, input semantics, and how to verify the result. It does not describe the proof's return format or mention authentication/rate limits, but those are not essential for correct invocation.

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

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

Both parameters already have detailed schema descriptions (byte-for-byte, max 16000 chars; self-declared, not verified). The tool description reinforces these points but adds little new parameter-level meaning, so it does not elevate the baseline 3 for high schema 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 states a specific action – timestamps and signs a third party's exact claim – and clarifies it does not express agreement. It also names verify_proof as the mechanism to check the resulting proof, distinguishing it from sibling 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 tool description implies its use case: witnessing a third-party claim without endorsing it, and points to verify_proof for subsequent verification. However, it does not explicitly contrast with alternatives like ledger_submit or enumerate when not to use the tool.

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