kuma

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 adds one useful behavioral trait ('Lean — each call returns only what you need'), but says nothing about whether 'init' mutates/persists session state, permission requirements, or rate limits, which is thin for an unannotated multi-action 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-loads the single most important instruction ('Call FIRST each session'), then lists actions in a scannable parenthetical format. Every sentence earns its place 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?

For a tool with no output schema and no annotations, it covers the action surface well and hints at output size ('lean'). It is slightly incomplete on the mutation/return-behavior side and on how the goal/scope/target parameters pair with specific actions, though the schema covers those parameters fully.

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 action enum already documents every action value, so the schema does the heavy lifting. The description's action list largely restates the enum description rather than adding syntax, format, or interaction detail (e.g. how scope and target relate to a given action).

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 ('Context & memory recall') and enumerates all nine concrete actions, so the agent knows exactly what the tool provides. It does not, however, distinguish itself from the sibling tools kuma_memory / kuma_safety, which overlap on 'memory recall'.

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 strong sequencing guidance ('Call FIRST each session') plus per-action context such as research 'before editing unfamiliar code', history 'why is this file written this way', and reuse 'before writing duplicate code'. It stops short of naming alternatives or when-not-to-use conditions against the sibling memory/safety 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. It discloses that output is lean ('each call returns only what you need') and that init restores session state, but says nothing about read-only vs mutating behavior, permissions, or side effects across the nine actions.

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 identity and the session-first directive before the action list, and the bracketed action glosses are compact. Slightly verbose in restating all nine actions, but each line earns its place as a routing hint.

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 nine-action multiplexed tool with no output schema, the description covers every action and key parameters adequately; the schema supplies the enum detail. It is nearly complete, missing only the behavioral/side-effect profile that annotations would otherwise carry.

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 action enum values are already documented in the schema, so the description largely restates them. It adds marginal value ('skeleton = compressed AST outline omitting bodies') but no new semantics for goal, scope, or target 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 resource ('context & memory recall') and enumerates nine concrete actions, so an agent knows the tool's domain. It does not differentiate itself from the near-identically named sibling kuma_context, which leaves ambiguity about which context tool to pick.

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

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

It gives an explicit timing cue ('Call FIRST each session') and embeds when-to-use hints per action, e.g. research 'before editing unfamiliar code', history for file rationale, and reuse 'before writing duplicate code'. It never names an alternative tool or states when NOT to use it.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose useful traits that go beyond the schema: records persist across sessions, arch_flow is scoped to a max of 5 core files, and gotcha_resolve archives rather than deletes. It says nothing about permission needs, overwrite/dedupe behavior, or failure modes, which is a real gap 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 value proposition, then a tight action list with parenthetical triggers; every sentence earns its place. Slight redundancy in restating the action semantics that the enum already defines, but no padding overall.

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, 7-action tool with no annotations and no output schema, the description covers action selection well but leaves important holes: the format of the 'record' JSON string for research_save, which parameters are required per action, and what any action returns. Adequate but not 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 100% and the action enum already documents each mode, so the schema does the heavy lifting — baseline 3. The description adds action-level intent but no parameter linkage (e.g., which params pair with gotcha_resolve or research_save's 'record' JSON string).

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 resource (persistent knowledge/memory store) and enumerates the seven core actions, so an agent understands it is a write/read memory tool with per-action intent. It does not, however, distinguish itself from the confusingly similar siblings kuma_memory and kuma_kuma_context, which matters a lot when names differ by one token.

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?

Strong per-action triggers are given ('IMMEDIATELY when you find a bug/quirk', 'when choosing between options', 'after tracing a complete flow, max 5 core files'), and there is an explicit exclusion: don't record what grep/glob answers faster. What is missing is routing against alternatives — there is no mention of when to use a sibling such as kuma_memory or kuma_context instead.

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 discloses meaningful traits such as the pairing of checkpoint+rollback_label as 'the one rollback mechanism' and implies state mutation/restore, but it never states permissions required, whether rollback destroys uncommitted work, or that guard/verify involve caching and rate limiting (only hinted at in the schema's 'force' 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?

The critical scoping rule ('task boundaries, not on every edit') is front-loaded, and the action list is compact and scannable. It is slightly redundant with the action enum descriptions in the schema, but 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?

For an 11-parameter, multi-action tool with no annotations and no output schema, the description covers the action semantics adequately but says nothing about what verify, cost, or guard return, nor about the snapshot/restore lifecycle details an agent would need. It is minimum-viable rather than 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 100%, and the action enum descriptions already spell out each action, so the baseline is 3. The description restates the action meanings largely in parallel with the schema and adds only the workflow relationship (checkpoint pairs with rollback_label); it does not clarify the other nine parameters 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 opening line names the domain ('Safety & verification') and the CORE ACTIONS block enumerates five concrete operations with their roles, so an agent knows this is a safety/verification toolkit. It is clear on what the tool does, but it never distinguishes itself from the sibling 'kuma_safety' or explains why two near-identically-named safety tools exist.

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?

Explicit timing guidance is given ('Use at task boundaries, not on every edit') plus per-action triggers ('before risky work', 'after edits', 'snapshot before risky work'). It also implicitly excludes overuse. What is missing is any routing advice versus the sibling tools, but the when-to-use guidance itself 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?

No annotations are provided, so the description must carry the full behavioral burden. It discloses that the store is persistent and saves time in future sessions, but it omits critical details such as mutation semantics, permissions, side effects, or write safety.

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 moderately concise but includes vague, motivational phrases ('Record what matters, skip what doesn't', 'This is what saves time in future sessions') that do not add actionable information. The action list is structured with a header, but the overall text is not as front-loaded as it could be.

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?

Given the tool's complexity (7 actions, 17 parameters, no output schema, no annotations), the description adequately covers action usage but leaves significant gaps in behavioral context and return value expectations. It is sufficient to guide action selection but not to fully understand the tool's 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?

The input schema has 100% description coverage, so the baseline is 3. The description adds usage triggers for each action but does not clarify parameter formats or syntax beyond what the schema already 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?

The description defines the tool as a persistent knowledge store and enumerates its core actions, making the tool's purpose reasonably clear. However, it does not differentiate this tool from its siblings (e.g., kuma_context, kuma_safety), so an agent has no explicit guidance on when to choose this tool over others.

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 provides explicit triggers for each action (e.g., 'gotcha' immediately when you find a bug/quirk, 'decision' when choosing between options) and a when-not rule for what to skip ('Don't record what grep/glob answers faster'). It does not address when to use this tool versus sibling tools, but the action-level 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?

With no annotations, the description carries the full burden and does reasonably well: it discloses that guard checks anti-patterns/drift/loops, verify runs scoped tests plus validation, and checkpoint/rollback is 'the one rollback mechanism' that snapshots and restores. It stops short of stating side effects (filesystem snapshots), persistence, or permission/caching behavior — the cache/rate-limit hint only surfaces in the schema's force param.

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 purpose sentence, then a compact action list where each parenthetical earns its place by adding timing or output context. Slightly dense but no wasted sentences.

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 11-parameter, no-annotation, no-output-schema dispatcher, the description supplies the action routing and timing that the schema cannot. It omits any mention of what the actions return or of side effects such as snapshot creation, which leaves a small but real 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?

Schema description coverage is 100%, including a per-value description on the action enum, so the structured data already documents every parameter. The description's action glosses largely restate the schema's enum description, adding little new syntax or format meaning, so 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?

The description names a specific domain (safety & verification) and enumerates the five core actions with a one-phrase purpose each, so an agent knows exactly what this dispatcher does. It does not explicitly differentiate itself from siblings like kuma_context or kuma_memory, though the safety/verification framing implies the split.

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

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

It gives an explicit when ('use at task boundaries') and an explicit when-not ('not on every edit'), plus per-action timing: guard before risky work, verify after edits, checkpoint before risky work, rollback after. This is exactly the routing guidance a multi-action tool needs.

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