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

Annotations already declare readOnly, idempotent, non-destructive and openWorld, so safety is covered. The description adds genuinely useful behavioral context beyond that: 'Free: no credits are charged,' which tells the agent invoking this has no cost side effect and is safe to call freely. It does not discuss auth/rate limits, but those are minor here.

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 what is returned, followed by when to use it and the cost caveat. Every sentence carries information; no padding or repetition.

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

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

For a zero-parameter read tool with an output schema, full annotation coverage, and rich context signals, the description supplies everything an agent needs: what it returns, when to call it, and that the call is free. Nothing material 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 the baseline is 4; there is no parameter semantics to add. Nothing in the description misleads about 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?

States a specific verb and resource ('Show this key's remaining Singularis credits') plus a second dimension of value ('cloud-equivalent dollars of compute delivered so far'). The scope is narrowly the current key's balance, which cleanly distinguishes it from the compute/inference siblings like singularis_gemm or singularis_dispatch.

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 two concrete trigger conditions: 'Use before a large job' and 'when a user asks what Singularis has cost or saved.' That is clear usage context. There are no competing balance tools among the siblings, so there is nothing to exclude, but it stops short of explicitly stating it is the only cost-checking path.

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

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

Annotations already declare the safety profile (readOnlyHint=false because it can write, destructiveHint=false, idempotentHint=true, openWorldHint=true), so the bar is lower. The description still adds real value beyond them: the return form (blurred array vs. written path), a mass-conservation check, and cost scaling as pixels * sigma. It leaves out whether an existing out_path is overwritten.

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 dense paragraph, correctly front-loaded with what the tool is, followed by inputs, outputs, and cost. The keyword tag list is compact but slightly opaque; nothing is truly wasted, though the sentence is packed.

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 an output schema present, return-value documentation is not strictly required, and the description still summarizes it. It covers formats, inputs, cost, and output targets for a 4-parameter tool, missing only the path/image interaction rule and failure modes.

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

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

Schema description coverage is 0%, so the description must carry the burden, and it largely does: it explains that inputs arrive as an inline array or a path, that sigma is in pixels, and that out_path is optional and only meaningful for image files. It does not resolve the relationship between path and image (mutually exclusive? precedence?) or what happens if neither is supplied.

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 precise verb and resource ('Gaussian blur of a 2D array or an image file') and enumerates the accepted formats (.npy, .png, .jpg). No sibling in the list performs a blur, so an agent can identify this tool's niche immediately without opening the schema.

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

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

The tag list 'smoothing, denoising, scale-space, preprocessing' implies the contexts in which this tool is appropriate, which is more than nothing. However, there is no explicit when-to-use statement, no when-not-to-use guidance, and no named alternative (e.g., fft/fft2 for frequency-domain work) to route between.

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

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

Annotations already declare the mutation/idempotency/open-world profile, and the description adds real context beyond them: bit-exact lossless semantics, the default output naming convention, and a post-run exact-restore hash check. It doesn't mention performance, size limits, or failure modes, 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?

Three tight sentences, front-loaded with purpose, then inputs, then return summary. Every sentence earns its place with no redundancy against the schema or annotations.

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

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

Despite an output schema existing, the description briefly summarizes the return payload (output path, bytes in/out, ratio, restore check), and covers inputs, semantics, and the decompress counterpart. Nothing needed to invoke correctly is missing.

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

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

With schema description coverage at 0%, the description carries the parameter burden and does: it defines path as a local file path and out_path as optional defaulting to path + '.sing'. Both parameters are meaningfully documented, though no format or path-type detail is 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+resource (compress a file) with the distinguishing qualifier 'exactly (lossless, bit-exact restore)'. Names the inverse sibling singularis_decompress, so an agent can immediately tell it apart from the many other singularis_* compute 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?

Gives concrete use cases (archives, datasets, logs, model checkpoints) and the selecting condition 'anything that must come back identical', plus routes to singularis_decompress for the inverse. It stops short of explicit when-not-to-use or non-lossless alternatives, so not a full 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?

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false and openWorldHint=true, yet the description adds meaningful context: the seal is verified before execution, a broken seal causes refusal with no charge, and cost is one job per operation. That is real behavioral value beyond the annotations, though what twist_in_transit overwrites is only implied.

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?

Purpose is front-loaded, followed by operations, safety behavior, inputs, and cost in a logical order. The 'sealed tower' metaphor is repeated enough to add some noise, but every sentence still conveys operational 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 annotations covering safety and an output schema covering return values, the description fills the remaining gaps: operation meanings, seal-verification behavior, required inputs, and cost. Only minor details (e.g., how params are structured and what 'portal energy' reports) are left unaddressed.

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

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

Schema description coverage is 0% and 'op' has no enum, so the description must carry the load. It supplies the valid op values and their semantics plus the sub-parameters (tower_in path, tower_out for twist, ridge), which the schema does not expose. It is slightly ambiguous about how these nest under the opaque 'params' object, keeping it from a 5.

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 (compute on a sealed tower in transit) and enumerates three concrete operations (fuse_in_transit, twist_in_transit, energy_audit), which lets an agent distinguish the modes of this tool. It does not explicitly differentiate itself from siblings like mind_merge_v2 or mind_combine_v2, so it stops short of a 5.

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

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

The operation list implies what each mode is for, but there is no explicit when-to-use / when-not guidance or named alternative (e.g., versus mind_merge_v2 or data_carry). Usage must be inferred from the operation glosses.

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 cover the safety profile (destructiveHint=false, idempotentHint=true, openWorldHint=true), and the description adds genuinely non-redundant behavior: the file is 'signed', 'a tampered carry is refused', results 'return digests and counts', and each operation costs 'one job'. The tamper-refusal and nonzero cost are valuable traits not derivable from annotations. It could still say more about failure modes, but this is solid.

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 dense but front-loaded: the core purpose leads, then operations, then inputs, then return/cost. Every sentence carries signal. The terse arrow notation compresses detail at some cost to readability, but nothing 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?

An output schema exists, so return values need not be spelled out, and the description is reasonably complete for understanding what the tool is. However, for a multi-operation tool with a fully untyped params object (0% coverage) and several competing siblings, the description does not supply enough invocation detail or routing guidance to be considered complete.

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

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

Schema description coverage is 0% – op is an untyped string with no enum and params is a free-form object. The description compensates partially by naming the valid ops (pack/verify/merge, functioning as an implicit enum) and sketching inputs ('source/carry paths, output path'), but it never maps which key inside params holds which path, so the params contract remains opaque.

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

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

The description names a concrete resource ('carry file') and enumerates the three operations it supports (pack, verify, merge) with a brief gloss on each. This lets an agent understand the tool without opening the schema. It does not, however, differentiate itself from overlapping siblings like singularis_mind_merge_v2, singularis_mind_combine_v2, and singularis_knowledge_packs, 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?

By describing what each op does ('pack (mind statistic files -> one carry file)', 'verify (check a carry file's seal and digest)', 'merge (combine carry files)'), the description implies when each operation applies. But it gives no explicit when-to-use/when-not guidance and never addresses the near-identical merge/combine siblings, leaving selection to inference.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds genuinely new behavioral context: restoration is bit-exact and a hash check is performed, which tells the agent the output is verifiable and reversible with respect to compression. It does not say what happens when out_path collides with an existing file.

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 purpose followed by inputs and return value; no filler. The terse 'Input: the .sing path; optional out_path' list style is efficient though slightly clipped.

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 an output schema present the description needn't detail return values, and it covers the round-trip contract with singularis_compress. But for a file-writing operation the destination behavior (default output location, overwrite behavior) is unspecified, which is a real completeness gap for a 2-parameter 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 0%, so the description carries the burden; it does add that the path is a .sing file and that out_path is optional, which is more than the bare schema. However it never explains the semantics of out_path being null (where the file lands by default) or what a supplied out_path means, leaving a meaningful gap.

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

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

States a specific verb and resource ('Restore a file') plus the scope qualifier 'bit-exact', and names the paired sibling singularis_compress, so an agent can immediately tell this apart from the compressor and the other compute 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?

Usage is only implied: the file must have been produced by singularis_compress, which routes the agent reasonably well. There is no explicit when-to-use framing, no statement of what happens if the input is not a .sing file, 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?

Goes well beyond the annotations by disclosing that results come with a 'check' and cost, and by flagging the non-obvious statefulness of learn/predict/fuse dispatches and the daemon requirement (SINGULARIS_ENGINE_URL) for multi-step learning. That stateful caveat is exactly the kind of behavioral context annotations cannot convey.

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

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

Front-loaded with purpose and examples, and the trailing daemon note is genuinely useful operational context rather than filler. It is slightly dense in the final sentence, but every sentence carries information.

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

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

An output schema exists so return details need not be spelled out, and the description nonetheless summarizes result/check/cost. For a complex open-world dispatch tool it covers usage, routing, and the statefulness gotcha; the only real gap is the undocumented 'size' parameter.

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

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

Schema description coverage is 0%, so the description must carry the load. It does clarify 'recipe' (name from the library, with examples) and 'payload' (JSON), but the 'size' parameter is never explained and no payload shape guidance is given beyond 'JSON'.

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 ('Run any job from the Singularis recipe library by name with a JSON payload') and gives concrete recipe examples. It also distinguishes itself from the named sibling tools by scoping itself to tasks that aren't covered by them, and routes to singularis_recipes for the catalog.

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

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

Explicitly says 'Use when a numerical task is not one of the named tools', which is a clear use condition and an implicit exclusion against the named siblings, plus a pointer to singularis_recipes for names and schemas. It stops short of naming a specific sibling alternative or giving a when-not example, so it is strong but not exhaustive.

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

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

Annotations declare the safety profile (idempotent, non-destructive, open-world), and the description adds traits beyond that: a Parseval energy check is returned, a complex signal round-trips exactly, and cost scales as N log N. These are genuine behavioral disclosures not present in the annotations or schema.

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

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

Front-loads the operation, then inputs, returns, inversion recipe, and cost. Sentences are dense and mostly earn their place; the return-format sentence is slightly redundant given an output schema exists, but the structure is clean.

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 an output schema present, return-value explanation is not required, yet the description still covers all four parameters, the inversion workflow, and performance characteristics. Nothing an agent needs to call it correctly is missing, other than sibling 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 0%, so the description carries the burden and largely does: x is 'inline or path', im is 'the imaginary part of a complex input, same shape as x', and inverse's meaning plus the x/im pairing is spelled out. This compensates well for the undocumented 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+resource (Fast Fourier transform of a 1D signal or 2D field) and enumerates concrete applications (spectra, convolution, circulant systems, filtering). It never distinguishes itself from the sibling singularis_fft2, and '1D or 2D of any size' arguably overlaps that sibling's territory, so an agent cannot route confidently between them.

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

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

Gives explicit instructions for the inverse path (pass real part as x, imaginary part as im, inverse=true), which is real usage guidance. However it offers no when-to-use/when-not versus singularis_fft2 or any other sibling, so alternative selection is left to inference.

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

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

Annotations already cover safety (destructive=false, idempotent=true, openWorld=true), so the description's job is lighter. It still adds real value: the input is a real field of any shape, cost scales as N log N, and a Parseval energy check accompanies the result — none of which appears in the annotations or schema. Minor tension: it reads as a pure computation while readOnlyHint=false implies state change, though no explicit read-only claim is made.

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?

Roughly four sentences, each earning its place: capability, use cases, input routes, return shape, cost, and sibling disambiguation. The most load-bearing information (what it computes) is front-loaded, and the sibling note is correctly deferred to a parenthetical at the end.

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-but-pure numeric tool with an output schema (so return values need no prose) and full annotations, the description covers capability, inputs, direction, and cost. The remaining gaps are the meaning of 'im' and the relationship between the x and path inputs when both are omitted.

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

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

With 0% schema description coverage, the description must carry parameter meaning, and it partially does: 'x inline or path' clarifies the two mutually exclusive input routes and 'inverse flag' names the direction control. It never explains the 'im' parameter (imaginary component) or the null-default/optionality semantics, leaving one of four parameters undocumented in both schema and prose.

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

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

States a specific verb and resource ('2D fast Fourier transform (or inverse) of a real 2D field') and adds concrete applications (image spectra, 2D convolution, field filtering). It also names the nearest sibling and positions itself against it: 'singularis_fft also accepts a 2D field; this tool is the explicit 2D entry.'

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 use contexts (spectra, convolution, filtering) and explicitly points at the alternative entry, singularis_fft. However it never states a rule for choosing between them — it only notes both accept 2D input — so the agent is left to infer which entry to prefer.

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

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

Annotations already declare openWorldHint=true, idempotentHint=true, destructiveHint=false and readOnlyHint=false. The description adds genuine context beyond that: it operates in a working directory (filesystem side effects), verifies homecoming exactly against the origin, refuses tampered packets, and consumes one job. It does not disclose what happens on failure, whether the working directory is created or must exist, or any permission requirements.

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

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

Three sentences, front-loaded with the tool's purpose and closed with inputs, returns, and cost. Sized reasonably, but the metaphorical narration ('born, hops between nodes, learns, and comes home') spends words on imagery rather than operational detail, so not 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?

An output schema exists, so the brief return-value summary is adequate and not a gap. Annotations cover the safety profile, so the description's added job is to explain inputs and side effects. It stops short: the working-directory contract, the meaning of 'key', and what the relay actually computes remain unstated for what appears to be a non-trivial, open-world, stateful operation.

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

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

Schema description coverage is 0% and the schema exposes only an opaque 'params' object, so the description carries the full burden. It partially compensates by naming the expected inputs ('work_dir; optional key'), which the schema does not reveal, but it never explains the format of work_dir or what the optional 'key' is for (registration key? idempotency key?), and the named inputs do not visibly map onto the single params wrapper.

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 verb and a resource ('Run a self-contained universe relay in a working directory') and sketches a flow (packet born, hops, learns, returns, verified), so the agent gets a rough idea. However the framing is heavily metaphorical ('universe', 'sealed packet', 'learns') and never states in plain terms what computation or simulation actually occurs, nor how it differs from siblings like singularis_dispatch or singularis_data_carry. Purpose is recognizable but vague.

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

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

There is no statement of when to use this tool versus the many sibling tools, no prerequisites, and no exclusions. The only orienting guidance is the cost note ('Cost: one job'), which tells the agent about budget but not about selection. The agent must infer applicability 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?

Annotations declare idempotentHint=true and destructiveHint=false, but the description adds meaningful context beyond them: a Freivalds-style probe residual check, inline-or-.npy return form, and cost scaling with 2*m*n*k. This is genuine behavioral disclosure an agent wouldn't get from annotations alone.

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

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

Front-loaded with the core formula, then inputs, then output/verification, then cost. Four dense sentences with zero filler; every clause adds information.

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

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

With an output schema present, the description needn't detail return values, yet it still notes the return form and verification. Combined with the input enumeration and cost note, an agent has everything needed to call it correctly.

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

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

Schema coverage is 0%, so the description must carry the load, and it does: it explains a/b can be inline or file paths (implying a_path/b_path), and that beta and c0 are optional. It does not explain beta's role precisely or how c0_path relates to c0, so it stops just short of full 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 exact operation (dense matrix product GEMM) and gives the formula C = A @ B with the optional C0 accumulation. An agent can immediately distinguish this from sibling tools like singularis_fft or singularis_solve_heat.

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?

"Use for any large dense multiply, including batches expressed as one tall matrix" gives clear positive usage context and a helpful edge case (batching). However, it offers no explicit when-not guidance or alternatives among siblings, 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?

Annotations already declare mutation, open-world behavior, idempotency, and non-destructiveness. The description adds useful behavioral context beyond that: wake requires 2-of-3 shares and refuses a single share, return is exact with zero difference, and each operation costs one job. It still does not describe failure modes or side effects of drop/create in detail.

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-loads the tool's purpose before listing operations, inputs, and cost. The phrasing is occasionally abstract, but every sentence contributes useful information. It avoids unnecessary repetition.

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

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

The tool is multi-operation and complex, and the description covers the operation set, share threshold, exact return behavior, and job cost. Because an output schema exists, return values need not be explained. However, the per-operation parameter requirements remain incomplete, which is a meaningful gap for invocation.

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

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

Schema description coverage is 0%, so the description must carry the burden of explaining parameters. It lists the valid op values in prose and says params are the paths an operation needs, but it does not map those paths to each operation or give names, types, or formats. This is only a partial compensation for an otherwise bare schema.

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

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

The description states a specific verb and resource: sending a working knowledge pack to another machine and bringing results home. It clearly enumerates the operations create, drop, wake, work, and return. It does not explicitly differentiate itself from any sibling tool, which keeps it from a 5.

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

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

The operation list gives implied guidance about what each operation does, including the 2-of-3 share requirement for wake. However, it does not say when to choose this tool over sibling tools or when not to use it. The guidance is operation-level rather than tool-selection-level.

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?

Goes beyond the annotations by disclosing the o(n^3) cost profile, that a residual check is returned alongside the result, and that the matrix may be supplied inline or via a path. It does not explain what happens if both matrix and path are given, or that non-square/degenerate input is rejected. The description does not contradict the annotations (it never claims read-only), so no contradiction flag.

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 operation, then use cases, then the alternative-selection rule, then inputs, then return and cost. Dense but every clause carries information; only the bare field list ('Inputs: matrix inline or path; t (default 1); optional vector') is slightly telegraphic.

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 an output schema present, the description need not detail return values, and it still notes the residual check. It covers use cases, the alternative, cost, and most inputs; the gaps are the undocumented vector_path parameter and the absence of any validity constraints on the matrix.

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

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

Schema description coverage is 0%, so the description carries the burden and does compensate partially: it explains matrix may be inline or a path, that t defaults to 1, and that vector is optional (enabling the e^{tA}v mode). However vector_path (a fifth parameter that overrides/augments vector) is never mentioned, nor is the required square shape or the t-scaling 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 precise mathematical verb and resource ('Compute the matrix exponential e^{tA} of a square matrix, or its action e^{tA} v'), then names concrete application domains (CTMC generators, linear ODEs, graph diffusion). It explicitly distinguishes itself from a dense expm sibling, so an agent can select it without ambiguity.

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 selection rule: 'Use instead of a dense expm whenever n is in the hundreds or more, or when you need a verifiable residual.' This states when this tool wins over the obvious alternative and enumerates the problem classes it targets.

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

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

Annotations already declare the mutation/idempotency/open-world profile, and the description adds genuinely useful context beyond them: no retraining and no data leaving the machine, quarantine exclusion of poisoned inputs, refusal of tampered shards, a returned digest/counts, and a cost model ('one job, independent of how the minds were trained'). This is meaningful behavioral disclosure for a mutating 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?

Front-loaded with the core action, then operations, inputs, return values, and cost in a logical order. It is dense and somewhat run-on with parentheticals, but every sentence carries information and nothing is redundant.

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 mutating tool with an output schema (so return values need not be re-explained) the description is largely complete: operations, quarantine/tamper behavior, inputs, and cost are all covered. The remaining gap is the absence of any differentiation from the near-identical sibling and the loose mapping of inputs to the opaque 'params' object.

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

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

Schema coverage is 0% and the schema exposes only an untyped 'op' string plus an unconstrained 'params' object, so the description carries the burden. It compensates well by enumerating the valid op values (merge, add, remove, merge_quarantine, export_shard, import_shard, merge_shards) and naming the expected inputs (mind file paths, output path, ridge default 1e-8), though it does not map these cleanly onto the 'params' object.

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 ('Combine trained minds (model files) into one by exact addition') and enumerates the supported operations, so the agent knows exactly what it does. However, it never distinguishes itself from the sibling singularis_mind_merge_v2, which sounds near-identical, leaving the agent to guess which one 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?

The description implies usage through operation names (merge, add, remove, merge_quarantine, export_shard, etc.) and gives conditional behavior, but never states when to prefer this tool over singularis_mind_merge_v2 or the other compute siblings. There is no explicit when/when-not guidance or prerequisite information.

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

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

Annotations establish the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=true), and the description goes well beyond them: no retraining, no data leaving the machine, quarantine of poisoned/corrupted inputs, refusal of tampered shards, and a cost model ('one job, independent of how the minds were trained'). The 'no data leaves this machine' claim sits in slight tension with openWorldHint=true but is about data egress rather than external interaction, so it reads as added nuance rather than a contradiction.

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 purpose is front-loaded in the first clause, followed by tightly packed op semantics, inputs, return, and cost — no filler sentences. The dense op enumeration is information-rich but slightly list-like rather than 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 an output schema present, describing the return ('merged digest and counts') is a bonus rather than a requirement, and the destructive/refusal behaviors plus cost model cover what a mutation tool needs. The only notable gap is the unexplained structure of the 'params' object, which an agent must guess.

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

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

Schema description coverage is 0% and the schema exposes only 'op' plus an opaque free-form 'params' object, so the description carries the burden. It partially compensates by naming the valid ops and expected inputs (mind file paths, output path, ridge default 1e-8), but never explains how those inputs map into the 'params' object or its key names, leaving a real gap.

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

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

'Combine trained minds (model files) into one by exact addition' gives a specific verb, resource, and mechanism, and the title identifies it as an alias of singularis_mind_combine_v2, distinguishing it from the compute-kernel siblings. However, the subsequent enumeration of seven distinct operations (merge, add, remove, merge_quarantine, export_shard, import_shard, merge_shards) blurs the single-tool identity somewhat.

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?

Per-operation behavior is sketched (quarantine excludes a poisoned input; shards are signed and tampered ones are refused), which implies when each op applies, but there is no explicit when-to-use-this-vs-alternatives guidance. The alias relationship with singularis_mind_combine_v2 is only in the title, not stated as a routing rule.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and openWorld, so the safety profile is covered. The description adds genuine behavioral context beyond that: the listing is exhaustive ('every job kind the service runs') and explicitly free of cost, which matters next to cost-measuring compute siblings.

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 the contents front-loaded and the usage/follow-up appended; nothing is padded. The one-word 'Free.' fragment is terse but carries real decision-relevant 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 an output schema present, the description needn't explain return values, and it correctly focuses on what the listing contains and how to act on it. Missing only minor operational detail such as ordering or pagination of the library listing.

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 4 baseline applies. The description correctly implies no filtering or scope arguments are needed, matching the empty argument 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 ('List the Singularis recipe library') and enumerates exactly what each entry contains — job kind, input schema, the check returned, and cost metric. This is enough for an agent to distinguish it from the runnable solver siblings 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 a clear trigger ('when a task is numerical but not covered by the named tools') and an explicit follow-up action ('then run it with singularis_dispatch'), naming the alternative tool by name. It lacks an explicit when-not statement, but the routing is unambiguous.

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 safety profile (not read-only, open-world, idempotent). The description adds substantive behavior the annotations cannot convey: the anti-abuse proof of work is solved automatically, the key is persisted for reuse, US-based users/agents only, agreement to external Terms, and that result sharing is requested but not required.

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

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

Front-loaded with purpose and trigger, then constraints, then legal terms — a sensible order. It is dense but nearly every clause adds operational information; the credits/terms sentences are the most expendable.

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

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

An output schema exists, so return details are not strictly required, yet the description still flags that the response includes starting credits. With annotations covering the safety profile, all preconditions (error trigger, required fields, US restriction, terms) are 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 coverage is 0%, so the description must carry parameter meaning. It does: country is an ISO code ('such as US'), agent_name should be 'short', and operator_contact is explicitly optional. It does not clarify what operator_contact should contain (email? handle?), which is the one remaining gap.

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

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

States a specific verb and resource ('Get a free Singularis API key for this agent') and immediately scopes it as a one-time provisioning step. No sibling tool in the list performs key registration, so the agent can distinguish it without opening a schema.

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

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

Gives an explicit trigger: 'Use when any Singularis tool reports error=no_api_key.' It also pre-empts repeat invocation with 'one call, then it is saved and reused', which is the relevant when-not condition for this tool.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false. The description adds useful context that sharing is optional and hardware-dependent, but it does not explain where results are shared, whether they are public, or what happens after submission.

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

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

The description is front-loaded with the action and then efficiently enumerates the expected inputs. It contains no significant filler and remains appropriately sized for an optional submission 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 an output schema present, the description need not explain return values, and annotations cover the safety profile. It is nearly complete, though it omits privacy or visibility details that would be useful for a sharing/submission 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 0%, so the description must compensate, and it names all six parameters with practical meaning: review, post_url, prior_cloud_usd, singularis_usd, speedup, and hardware. It could be stronger by clarifying units or formats, but it substantially covers the parameters.

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

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

The description states a specific verb and resource: 'Share your Singularis results.' It lists exactly what is being shared and is clearly distinct from the sibling compute 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?

It says sharing is 'optional, and appreciated,' which implies voluntary use, but it gives no explicit when-to-use, when-not-to-use, or alternative guidance. Usage is only lightly implied.

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

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

With annotations covering safety (readOnlyHint=false, destructiveHint=false, idempotentHint=true), the description adds real behavioral context: what is returned (final field inline or .npy path, plus a conservation/residual check), what each boundary mode does, and that cost scales with steps * cells. It does not flag stability constraints (e.g., dt vs dx^2/D), which a diffusion solver needs.

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

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

Front-loaded with the governing equation and scope, then inputs, then returns, then cost — a sensible order. The Black-Scholes aside and repeated 'inline or as a file path' phrasing are slight padding, but the text is dense and earns most of its length.

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

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

For a 7-parameter numeric solver with an output schema, the description covers inputs, boundary semantics, return shape, verification check, and cost profile. Since the output schema covers return structure, the extra return detail is a bonus rather than a gap; nothing needed to call it correctly is missing.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it enumerates every parameter (initial field inline or file path, diffusivity D, dt, steps, dx, boundary) and even supplies the boundary enum values ('periodic' default, 'neumann', 'dirichlet' fixed at initial values) that the schema lacks. It omits units/ranges or stability guidance for dt and dx.

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 verb and resource (solve the heat/diffusion equation u_t = D*laplacian(u)) and states the scope (1D/2D grid, time stepping). Sibling tools are all linear-algebra/utility primitives (fft, gemm, matrix_exponential) with no competing PDE solver, so the purpose 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?

"Use instead of writing a stencil loop whenever steps * cells is large" gives an explicit alternative and threshold for choosing this tool, and the Black-Scholes remark adds a second legitimate use case. It stops short of stating when NOT to use it (e.g., small grids or non-diffusive PDEs).

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