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

No annotations are provided, so the description carries full responsibility. It correctly implies a read operation and lists output fields, but does not disclose additional behavioral traits such as rate limits, authentication requirements, or whether the log is per-session, limiting 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 efficient sentences. The first sentence states the core purpose; the second adds output details and usage context. No unnecessary words.

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

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

Given the tool's simplicity (one optional parameter, no output schema, no nested objects), the description covers input, output fields, and a usage hint. It does not specify the output format (e.g., list or object) but enumerates the fields, making it sufficiently 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?

The only parameter 'limit' is fully described in the schema with default and max values (100% schema coverage). The tool description adds no extra semantics beyond that, so the baseline score of 3 applies.

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

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

The description clearly states 'Read the audit log' with a specific verb and resource. It enumerates the fields shown (timestamp, method, description, success/failure, duration), differentiating it from sibling tools like civil3d_health (likely current state) and civil3d_execute (actions).

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 labels the tool as 'useful for debugging and traceability,' providing context for when to use it. However, it does not explicitly state when not to use it or mention alternatives among the 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 provided, so description carries full burden. The command-line analogy hints at behavior but lacks detail on side effects, errors, or behavior for destructive commands beyond the schema's confirmed param.

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

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

Two sentences: first defines purpose, second gives usage guidance. No wasted words.

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 no output schema and no annotations, the description is nearly complete. It explains when to use, provides examples, and mentions alternatives. Could mention default timeout but that's in schema.

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

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

Schema covers 100% of parameters, so baseline is 3. The description adds value by giving example command strings and context, justifying a score of 4.

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 executes a native command string, provides examples like CREATECORRIDOR, and distinguishes from siblings by recommending civil3d_execute/civil3d_query when API is sufficient.

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

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

Explicitly tells when to use (operations not easily done via C# API) and when to prefer alternatives, with specific command examples.

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 provided, so description carries burden. It discloses read-only behavior implicitly (discover, no write) and states return format, but does not detail side effects, auth requirements, or performance limits. Adequate but could be more explicit about safety.

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

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

Two sentences with no waste. First sentence states purpose and return format; second gives usage priority. Every word earns its place.

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

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

Given no output schema, description adequately explains return value (structured JSON with specific object types). Covers categories parameter. For a discovery tool with three optional params, this is fully sufficient.

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 schema already documents all three parameters well. The tool description mentions categories inline but adds no new meaning beyond the schema. Baseline 3 is appropriate.

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

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

Description clearly states the tool discovers and inventories Civil 3D drawing objects without writing C# code, returning structured JSON for many object types. It distinguishes from siblings like civil3d_execute, civil3d_query by stating a specific resource and action.

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

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

Explicitly advises 'Use this FIRST to understand what exists in the drawing before executing code.' This gives clear when-use guidance. While it doesn't list all alternatives, the sibling context implies other tools for execution or querying.

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?

Discloses execution in a committed transaction with write access, available globals, helpers, and automatic namespace imports. However, does not explicitly mention error handling or rollback on failure, which would further aid 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 a single, dense paragraph with front-loaded purpose, using minimal words to convey all necessary information without redundancy.

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

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

Covers the return format ('Return a value to get results back as JSON'), available globals, and helpers. Lacks explicit mention of error behavior (e.g., exception handling), but overall sufficient for a code execution tool with no output schema.

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

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

Schema coverage is 100%, but the description adds value beyond schema by explaining the code execution context (available objects, helpers) and the confirmed parameter's purpose for destructive operations. It also provides an example for the code 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?

Clearly states the tool executes C# code with write access in Civil 3D, specifying the verb and resource. It also distinguishes from siblings by referencing civil3d_session and civil3d_command for different use cases.

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

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

Explicitly provides when-to-use alternatives: 'Use civil3d_session for multi-step workflows. Use civil3d_command for native C3D commands.' This guides the agent on tool 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?

No annotations provided, so description carries full burden. It discloses return values and implies read-only operation. However, it does not explicitly state whether the tool has side effects or requires authentication, though for a health check this is reasonable.

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 efficiently state purpose and usage advice. No unnecessary words. Front-loaded with key 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?

Given no parameters and no output schema, the description adequately specifies what the tool does and what it returns. For a simple health check tool, this is complete and covers all necessary context.

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

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

No parameters in schema, but description adds meaning by explaining the tool's purpose and what it returns. Since schema coverage is 100% (no params), baseline is 4; description adds context beyond 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?

Description clearly states 'Check Civil 3D MCP connection health' with specific return values (status, version, drawing info, queue state). However, it does not differentiate from sibling tool 'civil3d_status', which likely has overlapping functionality.

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

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

Explicitly advises 'Call this first to verify Civil 3D is running and the plugin is loaded.' Provides clear context for when to use, but lacks exclusionary guidance (e.g., when not to use) or mention of alternatives among siblings.

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

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

No annotations provided, so description carries burden. Clearly states read-only behavior, available globals (Doc, CivilDoc, Database, etc.), helpers, and auto-imported namespaces. Does not cover error handling or timeout behavior in detail, but safety is well addressed.

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?

Description is front-loaded with key constraint (READ-ONLY), then lists globals/helpers, example usage, and ends with clear purpose statement. Efficient at ~100 words, no fluff.

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 query tool with no output schema, description explains return format (JSON if value returned) and available context (globals, helpers). Covers all essential aspects for agent to use tool correctly. Could mention error responses but overall 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 100% but description adds significant value: explains what globals and helpers are available, provides a C# example for the code parameter, and gives default timeout (120000 ms). This greatly aids the agent in crafting correct inputs.

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

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

Description clearly states the tool executes C# code in Civil 3D in READ-ONLY mode, with specific verb 'Execute' and resource 'C# code in Civil 3D'. It distinguishes from siblings like civil3d_execute (likely write) and civil3d_command (different execution style).

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

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

Explicitly says 'Use this for querying data' and lists examples. Implies not for modifications, but does not explicitly state when not to use or mention alternatives like civil3d_execute for write operations.

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

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

With no annotations provided, the description fully discloses the tool's behavior as a read-only policy query. It details the returned information without claiming any side effects, making it transparent for safe invocation.

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 sentence that is front-loaded with the tool's purpose and efficiently packs all critical information: what it reads, what it returns, and when to use it. No wasted words.

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

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

Despite having no output schema or annotations, the description is self-sufficient. It fully explains the tool's return value and usage context, meeting all needs for a simple info-retrieval tool.

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

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

Input schema has zero parameters (100% coverage), so the description adds meaning by explaining the output. Although no parameter details are needed, the description enriches the tool's purpose beyond the empty schema.

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

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

Description clearly states it reads the Civil 3D MCP security policy, specifying exactly what information it returns (sandbox mode, allowed export paths, destructive operation confirmation). It distinguishes itself from sibling tools like civil3d_health and civil3d_execute by focusing on security policy.

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

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

Explicitly advises the agent to call this tool before file exports or destructive writes, providing clear usage context. No alternatives or when-not-to-use guidance is needed given the tool's singular purpose.

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 full burden. It discloses key behaviors like the lifecycle (begin, execute, commit, abort) and that execute does not commit. However, it does not mention potential destructiveness of commit/abort, prerequisites, or side effects. Adequate but not thorough.

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 purpose, then listing the actions. Every sentence is necessary and no words are wasted. Highly concise and well-structured.

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

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

Given the complexity (5 parameters, session lifecycle, no output schema), the description covers the main user flow and action semantics. However, it omits details like error handling, timeouts, or prerequisites (e.g., need to be in a Civil 3D environment). Still, it is largely complete for a session management tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds context about actions (e.g., 'execute for each script step (no commit)') but does not elaborate on parameters like code, sessionId, or confirmed. The value added is marginal.

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

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

The description clearly states the verb 'Manage' and the resource 'multi-step Civil 3D script sessions', distinguishing it from sibling tools like civil3d_execute and civil3d_command. It provides specific actions (begin, execute, commit, abort) and their purposes, making the tool's function unambiguous.

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

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

The description states it is 'useful for complex workflows that need multiple code steps in one transaction', implying when to use it. However, it does not explicitly mention when not to use it or name alternatives, though sibling tool names provide some context. A clearer exclusion would improve the score.

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 must convey behavioral traits. It implies read-only behavior through 'Browse and read' and actions like list/search/get, but does not explicitly state it is non-destructive. The lack of destructive mentions is acceptable for a clearly read-only 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?

The description is two sentences, no wasted words, and front-loads the purpose. It efficiently covers actions, usage, and relationship to sibling tools.

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

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

The description adequately covers the tool's purpose and actions, references sibling tools for execution, and mentions that 'get' returns a full code template. However, it lacks details about output format or behavior for empty results, which is acceptable given the tool's simplicity.

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 baseline is 3. The description adds context by explaining the three actions and their mapping to parameters, but does not provide significant detail beyond what the schema already describes.

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

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

The description clearly states the tool browses and reads Civil 3D code skills, lists three specific actions (list, search, get), and distinguishes from sibling execution tools by noting that skills can be adapted and executed via civil3d_execute or civil3d_query.

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 clear context for using the tool (to find and read skills) and implicitly contrasts with execution tools, but does not explicitly state when not to use it or list alternative tools beyond mentioning civil3d_execute and civil3d_query.

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 must convey behavioral traits. It notes the tool is non-blocking ('without blocking the current operation'), implying a read-only status check. However, it omits details like error handling or that it doesn't modify data, leaving some 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 description is two sentences, front-loads the purpose and usage, and contains no redundant information. Every sentence serves a clear role.

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?

While the description explains what the tool does and when to use it, it lacks details on the return value (e.g., format, fields like queue length or task name). Without an output schema, the description should elaborate on the output structure.

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

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

There are zero parameters, so the description does not need to add parameter details. Schema coverage is 100% (all parameters documented), and the baseline for 0 parameters is 4, which is appropriate.

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

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

The description clearly states the tool retrieves 'real-time status of the Civil 3D plugin operation queue and any in-progress task,' using a specific verb and resource. It distinguishes from siblings like civil3d_health and civil3d_execute by focusing on status monitoring rather than diagnostics or actions.

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 advises using the tool 'during long operations (corridor rebuild, surface build) to check elapsed time without blocking the current operation,' providing clear context. It does not mention when not to use it or list alternatives, but the implied use case is sufficient.

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