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

With no annotations, the description carries the full disclosure burden, yet it omits the most consequential behaviors visible only in the schema: it may create an orchestrated session and reuse existing sessions by default (side effects), and it accepts an override token for "chaotic requests." Terms like "baseline audit" and "chaos detection" are never explained, so an agent cannot predict what the call changes.

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

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

A single compact sentence with the core action front-loaded and no filler. The problem is that the space saved is spent on unexplained jargon rather than on useful content, but structurally it is efficient.

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

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

A five-parameter tool with default-on session side effects, no annotations, and no output schema needs more than one abstract sentence. Nothing explains the return value (routing decision? complexity score? audit report?) or the session-creation side effect, leaving an agent unable to call it confidently.

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

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

Schema coverage is 80%, so most parameters are documented in the schema itself, which sets the baseline at 3. The description adds nothing about the five parameters — notably it never clarifies the interaction between reuse_session and create_session or what qualifies as a chaotic request needing override_token.

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

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

The verb+resource pair ("analyze task complexity") is identifiable, but the trailing clause "route appropriately with chaos detection, baseline audit and orchestration" is internal jargon that doesn't tell an agent what the tool concretely produces or how it differs from siblings like mcp_m7_scope, mcp_m7_task_graph, or mcp_m7_validate. Readable, but too abstract to differentiate.

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?

"Route appropriately" faintly implies this is an entry point to a workflow, but the description never states when to call this instead of mcp_m7_scope or mcp_m7_task_graph, nor any prerequisites. No exclusions, no alternates, no ordering 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?

No annotations are supplied, so the description carries the full behavioral burden and does not meet it. It never says whether actions like generate_c4 write files to disk, whether the tool is read-only, what permissions or project state it requires, or how expensive a full analysis is. Only the A-F grade output is disclosed, leaving the mutation/side-effect profile of a seven-parameter tool entirely unstated.

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

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

Front-loaded with a one-sentence capability summary followed by a scannable action list; nothing is padded. The sole redundancy is restating 'Architectural Advisor - analyze architecture' in the header.

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

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

For a seven-parameter, multi-mode tool with no annotations and no output schema, the definition leaves too much open: parameter usage, whether any action has side effects, and the shape of results beyond 'score (A-F grade)'. An agent could pick an action but not confidently configure or interpret the call.

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 29%, with only project_path and limit documented in the schema, yet the description explains no parameters at all. enabled_rules, disabled_rules, and severity_filter are undocumented in both places, and c4_level's relationship to the generate_c4 action is only inferable from the action name. With low coverage, the description was required to compensate and does not.

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 a specific verb set and resources: analyze architecture, detect antipatterns, generate C4 diagrams, suggest refactoring. The action enumeration makes the tool's scope unambiguous even against a large sibling list. It stops short of explicitly distinguishing itself from neighbors like mcp_m7_scope or mcp_m7_get_patterns, which also touch architectural concerns.

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?

Each action is paired with a one-line intent (analyze = full analysis with grade, score = quick summary, critical_issues = only critical problems), which gives the agent concrete context for picking a mode. There are no exclusion rules or guidance on when another sibling tool would be preferable, so it lands at clear-context-without-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?

No annotations are provided, so the description carries the full behavioral burden. 'Check' hints at a read-only operation, but it does not state whether the journal is read-only, where it is scoped, what format results take, or whether any authentication is required. This is minimal for a tool with zero annotation coverage.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the tool's action and intended benefit immediately.

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

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

The tool is simple (one optional parameter, no output schema), but the description omits what a journal entry contains, how error_type filters results, and how it differs from overlapping siblings. These gaps are not fatal for a simple read tool, but they leave the agent with insufficient context to use it confidently in a crowded toolset.

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

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

Schema description coverage is 100%, and the single optional parameter error_type is already documented as 'Type of error to check (optional)'. The description adds no further meaning such as accepted error-type values or filtering behavior, so the schema does the heavy lifting.

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

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

The description states a specific verb ('Check') and resource ('error journal') and adds the goal 'to avoid repeating past mistakes'. However, it does not differentiate from closely related siblings such as mcp_m7_error_database or mcp_m7_repentance, leaving an agent unsure which to select.

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

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

The phrase 'to avoid repeating past mistakes' implies the tool's purpose and a general usage context, but there is no explicit guidance on when to use it versus alternatives like mcp_m7_error_database or mcp_m7_repentance. No exclusions or prerequisites are provided.

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

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

No annotations are provided, so the description carries the full burden. Beyond a vague hint that it looks for 'safety patterns and potential issues,' it says nothing about read-only behavior, what the check actually inspects (versions? known CVEs? code?), how thorough it is, or what a result contains.

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

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

Single short sentence, front-loaded and waste-free, but the brevity is under-specification rather than efficiency. It is appropriately sized in form while failing to carry needed content.

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 eight parameters, no annotations, and no output schema, the description needs to carry far more weight than one clause can. Nothing explains what a 'check' produces, how results should be interpreted, or how the optional inputs change the analysis.

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

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

Schema coverage is only 63%, and the description mentions no parameters at all, so the undocumented ones such as 'constraints', 'preferences', and the 'team_experience' enum are left ambiguous. For an 8-parameter tool, the description does nothing to clarify intent or accepted formats.

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 verb ('Check') and a resource ('technology stack'), so the general area is clear, but 'safety patterns and potential issues' is vague about what is actually evaluated. It offers no differentiation from siblings such as mcp_m7_safety_verify, mcp_m7_get_patterns, or mcp_m7_arch_advisor, which plausibly overlap.

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

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

There is no statement of when to call this tool, when not to, or which sibling to prefer for adjacent concerns. An agent must guess whether this belongs before project setup, during review, or alongside safety_verify.

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 hints at monitoring and error capture, but does not disclose action-specific behavior, side effects, persistence, or the destructive nature of the 'clear' action. It also does not explain what 'start' and 'stop' do or how filtering affects captured data.

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

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

The description is a single short phrase, which is technically concise but is severely under-specified for a tool with six actions and nested filtering. The word 'Smart' is marketing filler and does not help the agent decide or invoke correctly. The description is not front-loaded with actionable information because none is present.

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 a required action enum with six values, a nested filter object, no annotations, and no output schema, the description is not complete enough to guide safe or correct invocation. It does not explain lifecycle operations, error retrieval, filtering behavior, clearing implications, or what the tool returns. An agent would need to rely entirely on schema inference and trial-and-error.

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 description mentions none of the four parameters. It says nothing about 'action', 'limit', 'filter', or 'minutes', and gives no meaning to the nested filter object's severity, maxLength, excludeLoops, includeContext, or excludePatterns fields. The schema's enum values are the only guide, and the description adds no semantic value.

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 vague purpose, 'console monitoring and error capture,' but gives no specific verb or action orientation. It does not mention the six action modes (start, stop, get_errors, clear, filter, status) that define what this tool actually does. It also does not distinguish this tool from siblings such as mcp_m7_check_errors or mcp_m7_error_database.

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 no guidance on when to use this tool versus alternatives. It does not explain when to start monitoring, when to stop, when to retrieve errors, or when to clear logs. There are no exclusions or conditions named, leaving the agent to infer usage from the enum alone.

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

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

No annotations are provided, so the description carries the full disclosure burden and largely fails it. "Registry management" weakly implies both reads and persistent writes (register), but nothing states that 'register' mutates stored state, whether duplicates are rejected or overwritten, or that the tool is a multi-action dispatcher where behavior varies entirely by the 'action' value.

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

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

It is a single short sentence with no wasted words, so it is not bloated. But brevity here is under-specification rather than efficiency: the sentence ends before conveying the action-driven nature or any invocation context.

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

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

For a 6-parameter tool with a required enum action, nested objects, no output schema, and no annotations, the description is far too thin. Nothing tells the agent which action values require which companion parameters (e.g., register needs 'contract', check needs 'name'/'type'), making correct invocation largely guesswork.

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% across 6 parameters, including a nested 'contract' object with required name/type/purpose and a 'filter' object, yet the description adds no parameter meaning whatsoever. It doesn't even mention that an 'action' selector is mandatory, which is the single most important thing to know before calling.

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

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

The description names the resource (an API contract registry) and a broad goal (preventing duplicate methods), which is more informative than a bare restatement of the name. However, it gives no verb and never hints at the six distinct operations (register, check, find_duplicates, suggest_name, list, search) that the tool actually dispatches on, so an agent cannot tell what calling it concretely does.

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

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

"To prevent duplicate methods" loosely implies you'd check the registry before defining a new API method, but there is no explicit when-to-use, when-not-to-use, or reference to any alternative tool among the 35 siblings. With actions like 'check' vs 'find_duplicates' vs 'search' available, the absence of routing guidance is a real gap.

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 says the tool creates a file structure, but does not disclose whether it overwrites existing files, what permissions or side effects are involved, where files are created, or what the return behavior is.

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 two short clauses with zero waste, and the deprecation notice plus replacement tool are front-loaded. An agent gets the most important information immediately.

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

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

For a deprecated tool, the description sufficiently signals that it should be avoided in favor of mcp_m7_cycle. However, it remains thin for an agent that must invoke it anyway: there is no output schema, no annotations, and no explanation of the file-structure side effects or route semantics.

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 80%, so the schema already documents most parameters such as task_id, status, version, and description. The description adds no parameter meaning beyond the schema and does not clarify the important 'route' enum values (light, medium, heavy), but the baseline of 3 is appropriate given the 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 uses a specific verb and resource: 'Create M7 file structure for a task.' It also clearly marks the tool as deprecated and names the replacement, so an agent can distinguish its status from active siblings. The term 'M7 file structure' is somewhat jargon-heavy, but the core action is clear.

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

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

The description explicitly states '[DEPRECATED v5.0] Use mcp_m7_cycle instead,' which gives a direct alternative and effectively tells the agent not to use this tool for new work. This is exactly the routing information needed for a deprecated 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?

With no annotations, the description carries the full behavioral burden. It does not disclose whether actions like 'record', 'validate', or 'cleanup' mutate persisted data, whether cleanup is destructive or reversible, whether sessions persist across calls, or what permissions are required. The action names hint at behavior but the description adds no explicit behavioral context.

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

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

The description is long but well-structured with headings and bullet lines per action, and the purpose is front-loaded. Every action line maps to a real enum value, so the length is largely earned, though the catalog format could be slightly tighter.

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-action multiplexed tool with 9 parameters, nested objects, no output schema, and no annotations, the description is incomplete. It does not explain return values, persistence semantics, side effects of write actions, cleanup safety, or how action selection interacts with sibling tools, leaving material gaps for an agent 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?

Despite only 56% schema description coverage, the description documents per-action parameter requirements and nested shapes: action_data fields {type, tool?, input, output, file?, success, userFeedback?}, ci_result fields {type, success, details?, affectedInsights?}, and cleanup_options fields {olderThanDays?, belowConfidence?}. It also marks required parameters for start, search, and validate, adding clear value beyond the schema's top-level property descriptions.

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 the tool is for cross-session learning across time and enumerates all 11 actions with one-line summaries, making the resource and capabilities clear. It does not explicitly differentiate itself from siblings such as mcp_m7_session or mcp_m7_memory, 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?

Each action line implies when that action is used (e.g., 'start tracking a new session', 'record an action in current session'), but there is no explicit guidance on when to choose this tool over sibling tools like mcp_m7_session, mcp_m7_memory, or mcp_m7_validate. The action catalog is helpful but leaves alternative 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?

No annotations are provided, so the description carries the full behavioral burden. It says the tool starts or continues a stateful cycle, but it does not disclose side effects, state transitions, permissions, error behavior, or what is returned; the phase list is workflow context rather than behavioral transparency.

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

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

The description is two sentences, front-loaded with the core action and followed by the phase sequence. It is efficient, though the phrase 'explicit phase instructions' is somewhat ambiguous given the schema has no phase parameter.

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

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

This is a complex stateful workflow tool with no annotations and no output schema, so the description should carry more of the explanatory load. It names the phases but omits how phase instructions are supplied, how continuation differs from starting new, and what the caller should expect after 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 100%, so the schema already documents all four parameters, establishing a baseline of 3. The description does not add parameter-level meaning beyond the schema, and its phrase 'explicit phase instructions' is not mapped to any actual parameter.

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

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

The description states a specific verb and resource: start or continue an M7 cycle, and it names the seven-phase workflow. It is clear about the tool's overall role, but it does not explicitly distinguish this tool from nearby siblings such as mcp_m7_task_graph or mcp_m7_impact.

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 a contextual use case: structured task development through all seven phases. However, it provides no explicit when-not-to-use guidance and does not name alternatives or prerequisites for starting versus continuing a cycle.

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 explains the two-channel concept but does not disclose side effects (e.g., whether generate writes anything), permission requirements, validation behavior, output structure, or how policy presets affect results.

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

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

Two sentences, front-loaded with the acronym expansion and core operations, then the channel distinction. It is appropriately sized and has little waste, though the first sentence is somewhat list-like.

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

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

This is a complex 13-parameter multi-action tool with no annotations, no output schema, and only 54% schema description coverage. The description does not explain action-specific requirements (e.g., what validate needs versus generate), policy presets, or output format, so an agent would still need to infer a lot.

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

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

Schema description coverage is only 54%, so the description should compensate. It adds some meaning for the human and AI channels, but does not explain the action enum's extract/check/policies actions, the policy preset parameter, format, content_type, envelope, or ai object 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?

The description states a specific resource (Dual-Channel Content Envelope) and names generate, validate, render and lint as core operations, so the agent knows this tool produces and checks dual-channel content. However, it omits three valid actions from the schema enum (extract, check, policies), so its scope statement is incomplete.

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 explains what DCCE is but gives no guidance on when to use this tool versus alternatives, no exclusions, and no action-selection guidance. The sibling list contains many unrelated M7 tools, and the description does not help route between them.

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

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

No annotations are provided, so the description carries the full behavioral burden and it does not meet it. It never discloses that 'deploy' is a mutating, potentially dangerous operation requiring the 'confirmed' flag, nor does it describe idempotency, environment safety, or what any action returns.

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

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

A single short line is efficient and front-loaded, but for a router with 8 actions this brevity crosses into under-specification rather than conciseness. There is no wasted text, but also little earned text.

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 has 7 parameters, 8 enum actions, no annotations, and no output schema; the description covers roughly three of the actions and none of the state machine (e.g., that deploy may require confirm). For this complexity level, the description leaves the agent guessing on most of the surface area.

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

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

Schema description coverage is 100%, so every parameter and the action enum are already documented in the schema, and the description's mention of environments/validation/history only echoes three enum values. Baseline 3 applies since the description adds no format, ordering, or conditional-dependency detail beyond the schema.

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

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

The phrase 'DevOps registry' plus three capability nouns (environments, command validation, deploy history) gives a rough sense of the domain, but the tool actually exposes 8 distinct actions and the description names only three of them. An agent cannot tell from the text that actions like wizard, confirm, learn, or status exist or what they do.

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

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

There is no guidance on when to pick this tool over the many siblings (mcp_m7_safety_verify, mcp_m7_validate, mcp_m7_doctor, etc.), nor which action to choose for a given intent. The only implied usage is 'deployment-related things go here', which is too thin for an 8-action dispatcher.

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

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

With no annotations, the description carries the full burden, and it only says 'auto-fix'. It does not state what a fix mutates within .m7/, whether changes are reversible or backed up, or whether permissions are needed. For a tool that can write to project metadata, this is a significant gap.

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

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

A single front-loaded sentence with no filler. It is efficient, though the terseness contributes to the gaps in other dimensions rather than being a structural flaw.

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

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

A mutation-capable tool with no annotations and no output schema needs the description to explain what is checked, what is fixed, and what the user gets back. None of that is present beyond the one-line summary.

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 action/verbose/project_path are already documented in the schema. The description adds only the notion of auto-fix, without explaining the check/fix/report distinction or the consequence of each action; baseline 3 applies.

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

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

Names two concrete verbs (диагностика, авто-исправление) and a concrete resource (.m7/ directory), so the agent knows exactly what domain the tool operates on. It does not distinguish itself from plausible siblings like mcp_m7_validate or mcp_m7_check_errors, which also sound diagnostic.

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

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

The description gives no guidance on when to pick Doctor over validate/check_errors/safety_verify, nor any precondition such as whether .m7/ must already exist. Usage must be inferred entirely from the name.

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

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

No annotations are provided, so the description carries the full burden and leaves major traits undisclosed: 'clear' wipes all data but is not flagged as destructive or irreversible, there is no mention of persistence scope (session vs project vs global), no side effects noted for 'capture' (does it create or update patterns?), and no confirmation of what 'check' or 'search' actually do under the hood.

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 action-per-heading layout is front-loaded and scannable, with required markers inline. It is slightly padded by restating enum values already present in the schema (category, severity), but nothing is wasted at the sentence level.

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 21-parameter, eight-action tool with no annotations and no output schema, the description should cover per-action return shape, the destructive 'clear' semantics, and the format/agent_id parameters. It defines what each action does but leaves an agent unable to predict results or side effects of the riskiest operations.

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

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

Schema coverage is only 48%, but the description compensates meaningfully by mapping parameters to the action that consumes them and marking required ones per action — information the flat schema does not convey. It still omits behavioral fields the schema leaves bare: format (json/text), agent_id, tags, limit semantics, and what file is used for in 'check'.

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 (error pattern database for AI mistakes) and enumerates eight distinct actions (capture, check, search, stats, patterns, correct, report_fp, clear), so an agent can map intent to action. It does not, however, differentiate itself from strongly overlapping siblings such as mcp_m7_check_errors and mcp_m7_get_patterns, so the agent can't tell which tool to reach for without opening both.

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?

Each action gets a one-line gloss, which implies usage, but there is no explicit when-to-use/when-not guidance, no workflow sequencing (e.g., check before writing, capture after a correction), and no routing to mcp_m7_check_errors even though 'check' duplicates it in name. With 39 sibling tools the absence of any disambiguation is a real gap.

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

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

With no annotations at all, the description carries the full burden, yet it discloses nothing about behavior: no note that results are implicitly filtered by the min_confidence (0.7) and max_risk_score defaults, no indication of result ordering, pagination, or whether this is a read-only operation. The word 'recommended' hints at ranking but never explains confidence or risk scoring.

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

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

It is a single sentence with no wasted words and is front-loaded, but the brevity is a product of under-specification rather than discipline. There is room for one or two more sentences of high-value guidance without 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?

Given a 10-parameter tool with zero annotations and no output schema, the description is far too thin to guide correct invocation. An agent cannot know from this text how to construct meaningful filters or what the response will contain.

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?

Ten parameters with only 60% schema description coverage, and the description adds no meaning to any of them. The undocumented ones — tags, type, sort_by, category — are not explained, and the description never even mentions that filtering by pattern vs. antipattern, category, or risk thresholds is possible.

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 single sentence names a specific verb and resource ('get recommended patterns and antipatterns for a specific technology'), which is clearer than a bare restatement of the title. However, it gives no way to distinguish this from plausibly overlapping siblings such as knowledge_hub, arch_advisor, or style_guardian, all of which could also surface guidance for a technology.

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 indication of when this tool should be chosen over its many siblings, nor any stated prerequisites (e.g., must a project be initialized first via init_project?). The description offers no exclusions, no alternative routing, and no context about the intended workflow stage.

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

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

With no annotations, the description carries the full burden. It does disclose meaningful behavior: mode-dependent coordination strategies, model selection via LiveBench, self-learning across invocations, gatekeeper validation, and debate rounds with a fallback (max_rounds). What it omits is equally important for an orchestration tool: latency/cost profile of a multi-agent run, whether it persists state or emits side effects, and what the result looks like. Adequate but with clear gaps.

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

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

The purpose statement is front-loaded, which is good, but the 'v3.8.0 Features' bullet list is promotional filler ('SELF-LEARNING: System improves over time') and the three 'Use mode=...' lines largely restate the mode enum descriptions. Roughly half the text is redundant with structured fields.

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

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

For a 7-parameter tool with a nested plannerOptions object, no output schema, and no annotations, the description should carry more weight. It explains the modes well but leaves the caller uninformed about return shape, run duration expectation, state persistence, and interaction between priority/debate_mode/max_rounds.

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 every parameter including the nested plannerOptions carries its own description, so baseline is 3. The description adds mode semantics that align with the enum descriptions but adds nothing beyond the schema for priority, max_rounds, debate_mode, or the agents list interaction with modes.

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: 'Orchestrate multiagent collaboration for complex tasks using M7 Hive system.' The agent can tell this is the top-level orchestration entry point. However, it never distinguishes itself from plausible siblings such as mcp_m7_analyze_task, mcp_m7_mesh, or mcp_m7_dcce, which a 4 on this dimension would require.

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 selection criteria between the tool's own modes: dynamic for 'quick expert analysis', planned for 'complex tasks requiring decomposition and validation', fixed for legacy. This is genuinely actionable. It stops short of 5 because it offers no guidance on when to use this tool instead of the many sibling tools, nor any prerequisites or exclusions.

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

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

With no annotations, the description carries the burden and does well: it discloses data provenance (reports are saved automatically by mcp_m7_hive_coordinator) and the notable side effect that 'load' injects full report content into the conversation context, which has real cost implications. It stops short of stating error behavior for missing filenames or whether reports are project-scoped, so not quite 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?

Front-loaded with the capability, then immediately broken into per-action lines, then one line of lifecycle context. No filler sentences; every line carries an actionable point.

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

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

There is no output schema, so the description must characterize returns — and it does, specifying that list shows dates, topics, and sizes while load returns full report content. Combined with the automatic-save provenance note, an agent has everything needed to call this 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 already documents limit, query, action, and filename, setting a baseline of 3. The description adds operational meaning on top by tying each action to its parameter (load needs a filename, list is the discovery step first), which is genuine value beyond the schema's field-level text.

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

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

The first sentence states a specific verb pair (browse/load) and resource (past Hive analysis reports). The description also names the producing sibling, mcp_m7_hive_coordinator, so an agent can separate this read-back tool from the tool that generates the reports.

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 explicitly enumerates the two actions and the condition for each: 'list' to see saved reports, 'load' with a filename to bring a report into context. It also frames the real use case — referencing past analyses in follow-up discussions — which tells the agent when this tool is the right choice versus re-running analysis.

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

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

No annotations are provided, so the description carries the full burden, and it discloses almost nothing. "Анализ реальных изменений кода" hints at a read-only analysis of actual diffs, but there is no word on side effects, whether results persist, what sessionId does, or how the modes differ behaviorally.

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

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

It is short and not padded, but that brevity comes from under-specification rather than efficiency. The one useful signal (code change analysis) is there, but nothing is front-loaded about the required action parameter or the modes.

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 five enumerated actions, six parameters, no output schema, and no annotations, a single vague line is wholly inadequate. An agent cannot determine how to choose an action or what to expect from any of them.

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?

Six parameters at 50% schema coverage, including two enums (five action values, three depth levels) that have no descriptions at all. The description adds zero meaning beyond the schema — the five action values are the most important semantic gap and go entirely unexplained.

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

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

The description is essentially a restatement of the name/title ("Impact" → "Code Impact Analyzer") plus the vague tagline "анализ реальных изменений кода". It never mentions the five distinct operations (analyze, compare, reflect, patterns, history) that define what the tool actually does, so an agent cannot tell it apart from siblings like mcp_m7_analyze_task or mcp_m7_validate_implementation.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives among the ~35 sibling tools. The agent is left to infer everything from the tool name alone.

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

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

No annotations exist, so the description carries the full burden. It does disclose the write artifacts it produces, which is real value, but it says nothing about overwrite behavior when files already exist, whether the operation is idempotent, or what happens on partial failure. The force-parameter semantics for non-empty directories live only in the 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?

A single compact sentence with the verb front-loaded and no filler. The dash-separated artifact list is dense but every element earns its place; minor cost is that 'M7 ecosystem' is undefined jargon.

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

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

For a zero-required-parameter, six-parameter scaffolding initiator with no annotations and no output schema, the description covers what gets created but leaves out idempotency, failure/rollback behavior and what the caller receives. Adequate but with clear gaps against the tool's complexity.

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

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

Schema description coverage is 83%, above the high-coverage threshold, so the schema already documents force, domain, description, project_name, project_path and technologies. The description adds no additional meaning about any parameter, which is the baseline 3 case.

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

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

Specific verb 'Initialize' plus the resource 'complete M7 ecosystem', and it enumerates the concrete artifacts produced (Memory Bank, .cursorrules, project structure), which separates it from sibling mcp_m7_create_structure. It does not explicitly say how it differs from that sibling, 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?

'for empty projects' gives an implicit when-to-use constraint, and the sibling list contains create_structure and project_index that a reader must differentiate on their own. No explicit alternative is named and no 'do not use if X' guidance is given beyond the empty-project hint.

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

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

No annotations are provided, so the description carries the full behavioral burden and it drops the important parts: `clear` ("Clear the graph") is destructive with no warning, `import` overwrites/injects state with no explanation of merge vs replace behavior, and the tool is stateful in-memory yet nothing says the graph persists across calls or needs rebuilding per session. It also never states whether importing/building can fail or what a missing graph returns.

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 summary followed by scannable per-action headers with parameter bullets — the right structure for a 16-action dispatcher. It is long, but nearly every line maps to a real action/parameter; only a few definitions (e.g. bare "Clear the graph.") are too terse to earn their header.

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

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

With no output schema and no annotations, the description should describe return shapes and prerequisites, and it only does so for a few actions (metrics lists nodes/edges/coupling/cohesion/health grade). For query, search, dependencies, dependents, orphans, path, critical, and export it never says what comes back, and it omits the build-before-use ordering and statefulness an agent needs 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 description coverage is 94%, so baseline is 3, and the description earns the bump by binding flat schema properties to specific actions (rootPath required for build, nodeId required for dependencies/dependents, nodeId+targetId for path) — a mapping the flat union schema cannot express — plus useful defaults for include/exclude patterns. It still omits `maxDepth` and doesn't document `limit` for the query/critical actions.

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 resource and concrete verbs ("analyze code dependencies, detect cycles, find orphans, generate diagrams") and then enumerates all 16 actions, so the tool's scope is unambiguous. It does not, however, distinguish itself from overlapping siblings like mcp_m7_cycle, mcp_m7_impact, or mcp_m7_project_index, so an agent can't tell from the description alone which of those to prefer.

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 per-action parameter lists imply which action to reach for and give enough context to pick one, but there are no explicit when/when-not rules, no statement that `build` must run before query/metrics/cycles, and no guidance on choosing this over mcp_m7_cycle or mcp_m7_impact. Usage is inferable but not directed.

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

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

With no annotations provided, the description carries the full behavioral burden, and it falls well short. It does not disclose that rollback and migrate are destructive/reversible-or-not, that require_confirmation defaults to true and gates updates, or what force does on init. "Versioning and auto-sync" hints at behavior but gives no operational detail for a mutation-capable tool.

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

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

It is a single front-loaded sentence with no padding, which is structurally clean. But the brevity is achieved by omission rather than compression: for a ten-action polymorphic tool, one vague clause is under-specification, not conciseness.

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

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

This is a high-complexity tool — ten enum actions, seven parameters, no output schema, no annotations — and the description explains none of the action semantics or return behavior. An agent would have to infer the entire operating model from the enum values alone, which is inadequate for the complexity here.

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

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

Schema description coverage is 86%, so the schema already documents version, to_version, from_version, document_id, force, and require_confirmation. The description adds no parameter meaning beyond a passing reference to "versioning", so the baseline 3 applies — the schema does the work, the description is neutral.

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

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

The verb is a generic "Manage" and the resource is stated as "project knowledge base", with a modifier clause naming versioning and auto-sync as capabilities. That is more than a restatement of the name, but it never mentions the ten enumerated actions (init, sync, migrate, rollback, diff, status, etc.), so an agent cannot tell from the text what the tool actually does. It also fails to distinguish itself from close siblings such as mcp_m7_knowledge_graph, mcp_m7_memory, or mcp_m7_project_index.

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

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

There is no when-to-use guidance at all: nothing says when to pick this over knowledge_graph or memory, no prerequisite for init-before-sync, and no warning about which actions are destructive. The only routing signal is buried in the schema enum, not in the description.

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

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

No annotations are provided, so the description carries the full behavioral burden. It mentions 'random wisdom,' hinting at nondeterminism, but does not disclose side effects, return behavior, permissions, or whether the ritual changes any state.

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, first stating the ritual action and then listing its components. The flavor terms are colorful but slightly reduce operational precision rather than bloating the text.

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

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

With no output schema and no annotations, the description should explain what recitation returns and how each action behaves. It does not cover return values, action mapping, or side effects, leaving the agent with an incomplete picture despite some parameter descriptions in the 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?

The schema covers 67% of parameters, but the required 'action' parameter has no schema description and the description does not map the five action values to concrete behavior. Terms like 'Inner Litany' and 'Sevenfold Rite' loosely echo schema concepts but do not clarify how 'recite', 'section', 'rite', 'invoke', and 'sevenfold' differ.

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: reciting sacred texts from the Codex Martianus before beginning work. However, the operational purpose is vague because 'sacred texts' and 'Inner Litany' are in-world terms rather than concrete actions, and it does not distinguish the tool from siblings like mcp_m7_warmup or mcp_m7_init_project.

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 a clear timing cue: use 'before beginning work.' But it does not say when not to use it, how it differs from adjacent preparation tools, or which action to choose for a given situation.

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-disclosure burden. It usefully discloses that delete removes data from memory and disk, reload resyncs after manual edits, search cascades with early stop, and stats are deduplicated, but it leaves many mutation actions unexplained and does not cover permissions, reversibility, or return 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 well-structured with clear headings and a scannable action list, and the length is broadly justified by the tool's complexity. However, the action list is incomplete relative to the schema and could be more tightly integrated with parameter meaning.

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

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

For a 26-parameter, multi-action tool with no annotations, no output schema, and 0% schema description coverage, the description is not complete enough. It gives useful high-level framing but leaves out key action enum values and nearly all parameter-level invocation details.

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% across 26 parameters, so the description must compensate. It explains the action enum loosely and describes memory levels, but it omits several action enum values and provides no semantics for the many other parameters such as id, ids, query, content, path, confidence, or nested pattern/project fields.

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 this as a unified memory system with a five-level cognitive hierarchy and enumerates its actions, so the general purpose is understandable. It does not distinguish the tool from nearby knowledge-related siblings such as mcp_m7_knowledge_hub or mcp_m7_knowledge_graph, 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 description lists actions but gives no explicit guidance on when to choose this tool versus alternatives, nor does it state prerequisites or exclusions. The action names imply possible uses, but the agent must infer usage conditions.

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

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

With no annotations, the description carries the full burden, and it does disclose useful traits: required env vars, the fact that sync pushes state and pulls peers, and that push-file auto-notifies the peer. It does not cover write-safety (does pull overwrite local files?), secret handling, error semantics, or rate limits, and gives no return-shape hints despite there being no output schema.

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

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

Two headed sections backed by bulleted action glosses make a 22-action tool scannable, and the domain sentence is front-loaded. The legacy section is thinner than the remote one and there is some redundancy between action names and their parenthetical parameter hints, but there is little wasted prose.

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

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

This is a 29-parameter, 22-action omnibus with no annotations and no output schema, so the description must carry the load. Three enum actions are undocumented, return behavior is never described for any action, and no Python of when a lock is needed or what sync/pull do to local state, leaving meaningful gaps for a tool this complex.

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 baseline is 3. The description adds real value by mapping actions to parameter tuples (e.g., ask → to, question; reply → message_id, answer), but it omits the actions (task_lock, propose_intent, events) that own lock_action, intent_type, resource, ttl_ms, module, and peer_id, so those parameters have no action-level context in the description.

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

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

The description names the domain ('multi-instance communication and coordination') and enumerates every action with a short gloss, so the agent can see what the tool is for at a glance. However, it never differentiates itself from plausible sibling overlap (hive_coordinator, cross_session, task_transfer, hive_history), and several enum values (task_lock, propose_intent, events) are absent from the action list entirely, leaving parts of the surface unexplained.

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 remote-vs-local split plus the M7_MESH_RELAY/M7_MESH_SECRET/M7_WORKSTATION prerequisites and the 'init auto-detects remote if configured' note give real context for choosing a path. But there is no explicit when-to-use guidance between the described actions or against the mesh-like siblings, so an agent must still infer the selection.

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

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

With no annotations, the description carries the full behavioral burden. It implies file creation ('generate... PROJECT_INDEX.md') but never states that it writes to disk, whether existing files are overwritten, whether it is safe/idempotent, or what auto_update and force actually do to project state.

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

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

A single front-loaded sentence that identifies the artifact and its purpose without padding. It is efficient, though the brevity comes at the cost of the usage and behavioral detail noted elsewhere.

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

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

For an 11-parameter mutation tool with no annotations and no output schema, the description is too thin to be complete—it omits action-mode semantics, write/overwrite behavior, and parameter meaning. An agent could invoke it but would be guessing about mode selection and side effects.

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 64%, and the description adds nothing beyond the output file name. The central 'action' and 'template' enums have no schema descriptions and no explanation in the description, and 'sections' and 'exclude_patterns' are entirely undocumented, so the description fails to compensate for the coverage gap.

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

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

States a specific verb pair ('generate and manage') and a concrete artifact (PROJECT_INDEX.md) with its purpose ('comprehensive project information for AI assistants'). It does not, however, distinguish itself from likely-overlapping siblings such as init_project, create_structure, or scope, which an agent could easily confuse with index generation.

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

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

There is no guidance on when to use this tool versus the many siblings, nor any explanation of the four action modes (generate/update/scan/validate) that are the primary decision axis. The agent must infer usage entirely from the enum names in the schema.

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

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

With no annotations, the description carries the full burden. It does disclose meaningful behavior: confessions are persisted and surfaced publicly on a "Wall of Shame" and aggregated into statistics, which is a non-obvious social/visibility trait. However it says nothing about whether records are scoped per project, whether confess is idempotent, or what confess returns.

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 that lead with the identity and then enumerate the three actions in order. No filler, though the mythological framing costs a few tokens of clarity relative to plain language.

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

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

A six-parameter mutation tool with no annotations and no output schema needs more than two sentences. The description never explains the heresy categories, never indicates that heresy and the free-text fields belong to the confess action, and never says what wall_of_shame or stats return.

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 67% and four parameters already carry descriptions, so the schema does most of the work. The description adds nothing about the heresy taxonomy — the seven enum values (haste, severed_chain, whack_a_mole, etc.) are unexplained in both places — and does not clarify which parameters matter for which 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?

The description names three concrete capabilities — recording freestyle mistakes (confess), viewing the Wall of Shame, and tracking heresy statistics — which map cleanly onto the action enum. The thematic framing ("Litany of Unbinding", "heresy") is decorative but doesn't obscure the underlying record/view/aggregate triad, and it is distinguishable from siblings like mcp_m7_litany or mcp_m7_error_database by its self-audit focus.

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?

"AI confesses when it deviated from M7 methodology" implies the trigger for the confess action, but nothing tells the agent when to use wall_of_shame or stats versus alternatives such as mcp_m7_error_database or mcp_m7_validate. No exclusions or sibling routing are given, so usage is only implied.

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

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

No annotations are provided, so the description carries the full behavioral burden. It names the safety checks but does not disclose whether the operations are read-only, what permissions are needed, whether a detected jailbreak blocks anything, or what the result format contains.

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

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

The description is two compact sentences with the core purpose front-loaded and the action list immediately available. There is no redundant or wasted wording.

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

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

For a four-parameter, multi-action safety tool with no annotations and no output schema, the definition covers the basic purpose and modes but omits important context about outcomes, result shape, and mode selection. It is minimally 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 coverage is 75%, with most parameters documented in the schema itself. The description usefully lists the action enum values, but it does not add much meaning beyond that, such as clarifying which text/input/output fields are expected for each 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?

The description states a specific domain and concrete capabilities: jailbreak detection, intent verification, and output checking. It lists the available action modes, so the agent can tell what the tool does without opening the schema, though it does not explicitly distinguish itself from vaguely related siblings like validate or check_errors.

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 action names imply when each mode might be used, but the description never says when to choose scan_input versus full_check or verify_intent, nor when not to use the tool. Usage is inferable from the mode names rather than explicitly guided.

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 mentions consistency and duplicate prevention, but it does not explain what actions like update, sync, diff, or check_db actually do, whether they mutate state, or what permissions or side effects are involved.

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

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

The description is a single front-loaded sentence with no wasted wording. It is concise, though its brevity contributes to the gaps in action and parameter semantics.

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

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

This is a multi-action tool with an untyped changes parameter, no annotations, and no output schema, so the description should do more to explain how the actions differ. It gives only a high-level purpose and does not equip an agent to choose or invoke the correct action confidently.

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

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

Schema description coverage is 0%, so the description must compensate for four undocumented parameters. It names database, API, and architecture in passing, which partially maps to the component enum, but it leaves the six action values, format, and especially the untyped changes parameter unexplained.

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

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

The description states a specific verb and resource, 'Manage project schema', and names several schema domains. It is clear about the domain, but it does not distinguish this tool from many similarly named siblings such as validate, project_index, or create_structure.

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

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

There is no explicit guidance on when to use this tool versus alternatives, despite siblings like mcp_m7_validate, mcp_m7_check_errors, and mcp_m7_create_structure. The phrase about preventing duplicate databases implies a consistency role, but it does not define call conditions or exclusions.

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

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

With no annotations at all, the description carries the full burden of behavioral disclosure and provides none. It does not say that set-budget, extend, and rollback mutate state, whether changes are reversible, what rollback reverts, or what status/visualize return. A one-line slogan is wildly insufficient for a five-action mutation tool.

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

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

It is short and front-loaded, but the brevity is under-specification rather than conciseness: the single sentence leaves every operational question unanswered. No sentence here earns its place because none carries actionable information.

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

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

For a tool with five actions, a nested budget object, no annotations, and no output schema, the description omits everything an agent needs: action semantics, mutation/rollback behavior, required per-action parameters, and expected results. It is effectively a name-and-slogan entry only.

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 description mentions no parameters. The schema describes only reason and sessionId (50% coverage), leaving the five-value action enum, the nested budget object with files/lines/minutes/breaking fields, and each action's required arguments unexplained anywhere. The description does nothing to compensate for that gap.

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

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

The description 'Manage task scope and prevent scope creep' essentially restates the title 'Scope' and gives no clue which of the five distinct actions (status, set-budget, extend, rollback, visualize) it performs. An agent cannot tell from this text what an invocation actually does or how it differs from siblings such as task_graph or analyze_task.

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

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

There is no guidance on when to use this tool, which action to choose, or what alternatives exist. 'Prevent scope creep' hints at intent but gives no trigger conditions or exclusions, leaving the agent to guess against 35 sibling tools.

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

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

No annotations, so the description carries the full burden and delivers nothing: it does not disclose that mark_complete/complete_session/enforce_compliance are mutating operations, that 'force' bypasses guards, or what enforcement does to a session. The only behavioral hint ('enforcement') is a bare keyword.

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

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

It is short and front-loaded, but it is an under-specified fragment rather than a concise sentence; a handful of words are spent on domain nouns ('compliance', 'enforcement') that convey no actionable meaning. Compact, but not efficient in the sense of conveying information per word.

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

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

A 7-parameter tool with 6 actions, mutation paths, a guard-bypass flag, and no output schema or annotations demands far more than one dash-separated phrase. Nothing an agent needs to invoke this correctly (action selection, session_id defaulting, force semantics) is present.

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

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

Schema description coverage is only 57% (evidence is entirely untyped/undescribed, action has a 6-value enum with no descriptions, enforcement_action unexplained), and the description contributes zero parameter information. It fails to compensate for the coverage gap in exactly the cases where it is needed.

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

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

A noun-phrase label ('Unified M7 session management - status, compliance, completion, enforcement') that restates the tool's name and titles its domains, but never states a verb or what calling it actually does. An agent cannot distinguish it from siblings like mcp_m7_cross_session or mcp_m7_cycle based on this text.

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

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

No when-to-use guidance, no alternatives, no exclusions. With 6 enum actions spanning status reads and session completion, the description gives the agent nothing to decide which action to pick or when this tool is preferable to mcp_m7_cross_session.

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

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

No annotations are provided, so the description carries the full burden. It does disclose useful behavior: analyze learns patterns, validate uses the learned profile, check returns only blocking issues, fix mutates code. But it does not warn that 'clear' irreversibly destroys all learned data, say where corrections are persisted, or explain whether 'fix' writes to the file path given.

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 a domain one-liner followed by a scannable action-per-heading structure, which suits a ten-action dispatcher. It is slightly verbose in places and omits nothing wasteful, though the header repetition could be tighter.

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 ten-action, nine-parameter tool with no annotations and no output schema, the description should describe what each action returns (profile shape, stats contents, validate result fields). It covers inputs well but leaves output semantics entirely unspecified, and never explains the 'format' parameter's effect.

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 already 89%, so the baseline is 3, but the description adds real value by mapping parameters to actions and marking which are required per action (path for analyze, code for validate/check/fix, original+corrected for learn, corrections for import). The 'format' parameter is the only one left undocumented.

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 one-liner states a specific verb pair and resource ('Learn and enforce code style patterns'), and the action list disambiguates each mode (analyze, validate, check, fix, learn, profile, stats, export, import, clear). It does not differentiate itself from overlapping siblings such as mcp_m7_validate, mcp_m7_get_patterns, or mcp_m7_check_errors, which is why it falls 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?

Each action has a short gloss, and 'check' is distinguished from 'validate' as looking for blocking issues only, which implies a usage split. However, there is no explicit guidance on when to pick this tool over the many sibling validate/pattern tools, and no statement of preconditions (e.g., that validate requires a prior analyze/learn).

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 disclosure burden. "View and explore" weakly implies read-only, but nothing states whether any of the seven actions mutate graph state, whether a task_id must pre-exist, what happens on unknown IDs, or how large a subgraph the default depth=2 traversal may return.

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 single sentence is front-loaded and wastes no words, but concision here tips into under-specification: one clause cannot carry a seven-action surface. It reads as a title restatement rather than a usable instruction.

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

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

With no annotations and no output schema, the description is the only behavioral signal, and it does not say what each action returns (node lists, edges, rendered visualization) or how `subgraph`/`visualize` differ. For a multi-action tool with five parameters this leaves real gaps, though the name plus enum values give a minimal working picture.

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

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

Schema description coverage is only 60%: `depth`, `limit`, and `task_id` are documented in the schema, while `action` and `filter` have bare enums with no explanation, and `task_id`'s description is merely a restatement of which actions accept it. The description adds no parameter meaning whatsoever, so nothing compensates for the gap on the two enum 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?

"View and explore the task dependency graph" names a verb and a resource, so the general domain is clear. But this is a seven-action tool and the description never mentions the required `action` parameter or what status/list/get/links/subgraph/visualize/recent actually do, so an agent cannot tell which mode to pick or how this differs from siblings such as mcp_m7_knowledge_graph or mcp_m7_cycle.

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

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

There is no when-to-use guidance at all — no prerequisites, no exclusions, and no routing to the several plausible sibling tools (mcp_m7_cycle, mcp_m7_knowledge_graph, mcp_m7_task_transfer) that touch related graph/task territory. The agent must guess from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden and falls short. It doesn't say whether a transfer creates a new task and what happens to the original, whether it is reversible, that a reason is mandatory for the transfer action, or what permissions or side effects are involved. Only the triggering condition is disclosed.

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

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

A single front-loaded sentence with no filler, which is structurally sound. But the brevity reflects under-specification rather than density — the sentence is short because most of the tool's behavior simply isn't described.

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?

Five parameters, three distinct actions, no annotations, and no output schema — this definition needs substantial prose to be usable and delivers one clause. Two of the three actions are entirely undocumented, so an agent cannot confidently invoke anything but a plain transfer.

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 80%, which is just below the threshold where the schema alone justifies a baseline 3. The description contributes nothing about the parameters: it never mentions the action enum, the required reason for transfer, or the difference between task_id for history and session_id resolution. With a three-way enum driving the tool's behavior entirely undescribed, there is 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?

It names a verb and resource ("transfer tasks") and adds a trigger condition, which is better than a bare tautology. But the schema exposes three distinct actions (transfer, check_scope, history), and the description covers none of them explicitly nor distinguishes this tool from siblings like mcp_m7_scope or mcp_m7_task_graph. An agent reading only this sentence would not know the tool also performs scope checks and history lookups.

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?

"when scope grows beyond original estimate" is a real when-to-use trigger, not just a restatement. However, there are no when-not conditions, no mention of the alternative tools in a 38-sibling namespace, and nothing to tell the agent when check_scope would be the appropriate action 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 mentions consent but does not disclose data-collection scope, privacy implications, side effects of enable/disable, or what flush/export actually do.

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

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

The definition is a single front-loaded sentence with no wasted text. It is concise, though its brevity contributes to under-specification for a six-action 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?

The tool has six actions, a nested data_types object, and no annotations or output schema, yet the description explains almost none of this. An agent would need to infer behavior from the schema alone.

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

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

Schema description coverage is 100%, so the action enum and data_types object are already documented structurally. The description adds no parameter-level meaning beyond the schema 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 names the resource ('M7 Code Telemetry') and two activities ('manage consent, view statistics'), but the third phrase ('help improve AI models') is vague. It does not distinguish this tool from any sibling or explain the six action modes.

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

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

There is no guidance on when to choose status vs enable vs disable vs stats vs flush vs export, nor on prerequisites such as consent state. The description implies a telemetry/consent context but does not tell an agent when this tool is appropriate.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say whether the call is read-only, what happens to the supplied message, whether it logs or echoes, or what a success/failure result looks like — all relevant for even a trivial test endpoint.

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

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

A single short sentence, front-loaded with the purpose and free of waste. It is not a 5 because at this length the sentence has no room for a qualifying clause that would add real value.

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

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

The tool is structurally simple (one required string, no nesting, no output schema), so the description is close to sufficient. The remaining gap is behavioral: with no annotations and no stated result semantics, an agent still cannot predict what the call does beyond 'it's a test'.

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

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

There is a single parameter with 100% schema description coverage ('Test message'), so the schema already documents it. The description adds nothing about the message's role (echoed back, ignored, logged), which is the baseline-3 outcome for a fully covered schema.

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

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

The description states a purpose — verifying MCP integration — which goes slightly beyond the name 'Test Tool', so an agent understands it is a smoke-test/connectivity check. However, 'test tool' is a weak verb+resource pairing and nothing distinguishes it from the many other mcp_m7_* siblings, none of which is named as an alternative.

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 phrase 'to verify MCP integration' suggests calling it as a setup/sanity check. There is no explicit when-to-use, when-not-to-use, or comparison against sibling tools such as mcp_m7_validate or mcp_m7_doctor, which could plausibly be confused with a verification step.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not explain side effects such as what auto_fix changes, what capture_screenshots produces, whether track_metrics writes data, or what any action returns. For a 17-parameter multi-action tool, this is a severe transparency gap.

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

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

The description is a single short sentence, so it is concise in length but drastically under-specified for a tool with five actions and 17 parameters. The front-loaded 'Unified M7 validation operations' is clear, but the brevity is not earned given the complexity.

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 five distinct actions, a nested metrics object, 17 parameters, no annotations, and no output schema, the description is completely inadequate. An agent cannot determine action-specific behavior, parameter requirements, or expected results from this sentence alone.

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

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

Schema description coverage is only 6%, with only task_id documented in the schema. The description adds no parameter-level meaning at all and does not explain which of the 17 parameters apply to which action. This leaves nearly all parameter usage undocumented.

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 says this is a 'unified' validation tool and names four operation categories, which gives some sense of scope. However, it is vague about what each operation actually validates, and it omits the 'quality_check' action present in the enum. It also does not distinguish this tool from the sibling mcp_m7_validate_implementation.

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

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

There is no guidance on when to use this tool versus alternatives such as mcp_m7_validate_implementation, nor any explanation of which action to choose for a given situation. The description merely lists operation categories without selection criteria or 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?

No annotations are provided, so the description carries the full burden, yet it never says whether the tool is read-only, whether it modifies code, or what the report contains. It also leaves undefined how strict_mode, risk_threshold, and confidence_threshold change behavior, which matters for a 9-parameter analysis tool.

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

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

A single front-loaded sentence with no filler, so it is efficient. The brevity is a weakness in coverage rather than verbosity, which is penalized in contextual completeness instead.

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 9-parameter tool with no annotations and no output schema, the description omits the return shape (issues, fixes, metrics, scores) and the effect of the threshold parameters. An agent can call it, but cannot predict what it gets back or how to tune it.

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

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

Schema description coverage is 78%, just below the baseline-3 threshold, and two parameters (enabled_categories and the custom_rules object structure) have no description at all. The description adds nothing about parameters, missing the chance to explain categories or rule shape.

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

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

States a specific verb ('Validate') and resource ('code implementation') plus the criteria (safety patterns and best practices). It does not distinguish itself from close siblings such as mcp_m7_validate, mcp_m7_safety_verify, or mcp_m7_style_guardian, so an agent cannot tell from the description alone which validator 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?

No guidance on when to use this versus the many sibling validation tools, and no exclusions or prerequisites. With six-plus validator-like siblings in the list, the absence of routing guidance is a real gap.

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

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

With no annotations, the description carries the full burden. It does disclose useful behavior: 'start' spins up a server and opens a web UI, 'stop' tears it down, 'get_graph' returns JSON, and 'open' returns a URL. But it says nothing about port binding, whether start is idempotent, what happens to an existing server, or whether stop destroys state — all material for a stateful server-lifecycle 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 purpose followed by a scannable action list, then capability bullets. It is slightly longer than needed — the 'visualizer shows' bullets are nice-to-have context rather than invocation guidance — but no sentence is pure 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 six-operation stateful tool with no annotations and no output schema, the description should say more about return values for get_graph/status/open and about server lifecycle edge cases. It covers the happy path adequately but leaves an agent guessing about failure modes and per-action preconditions.

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 75%, so the baseline is 3, but the description earns an upgrade by explaining what each enum value actually does ('focus: Focus on a specific node', 'set_context: Update current file/task context') and tying node_id/file/task to their actions. The only gap is that no value formats or required-per-action combinations are stated.

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 a specific verb-and-resource combination ('interactive graph visualization of code dependencies') and the action list spells out each operation precisely. An agent can tell this is a server-lifecycle plus graph-query tool. It does not, however, differentiate itself from siblings like mcp_m7_impact or mcp_m7_knowledge_graph, which cover overlapping visualization/impact territory.

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 closing line gives a minimal workflow hint ('Use start to launch, then open the URL in browser'), but there is no guidance on when to pick this over mcp_m7_impact for impact analysis or mcp_m7_knowledge_graph for graph data, nor any stated prerequisites or exclusions. Usage is implied by the action names rather than explained.

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 disclosure burden. It hints that a report is produced ('выдаёт отчёт для проверки') but says nothing about caching behavior implied by `force`, what `invalidate` destroys, whether warmup mutates project state, or what the report contains. For a six-action tool with mutation-capable modes, this is a substantial gap.

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

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

Two short clauses, front-loaded with the system name and the core capability. Nothing is padded, though the brevity comes at the cost of covering only one of six actions rather than from tight editing of complete 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 six parameters, six enum actions, and no output schema, the description should explain the action space and the shape of the verification report. Instead it documents only the default warmup path, leaving a third of the tool's functionality and all of its return value opaque to the agent.

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

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

Schema description coverage is 100%, so every parameter including the action enum and scope levels is already documented inline. The description adds no additional meaning about parameters, which is acceptable here since the schema does the work, but there is no credit to give beyond the 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 names a specific capability — warming up project context for a new chat and returning a verification report — which is clearer than the bare title 'Warmup'. However, it only describes the 'warmup' action, while the required `action` enum exposes six distinct operations (status, invalidate, record, compliance, akstis) that the description never acknowledges. An agent cannot tell from this text that the tool is multi-modal rather than a single warmup routine.

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

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

There is no guidance on when to call this versus the many related siblings such as mcp_m7_session, mcp_m7_init_project, or mcp_m7_cross_session. Nor is there any indication of which of the six actions an agent should choose or when. Usage must be inferred entirely from the enum.

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