Moltline Agent Governance

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description reinforces these with 'Every call is read-only and idempotent, so after correcting the input it is always safe to retry.' Additionally, it discloses the error behavior: 'never raises a protocol error — it returns {"error": ...}'. This adds significant behavioral context beyond the annotations.

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

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

The description is concise (four sentences) and front-loaded with the primary purpose. Each sentence adds distinct value: purpose, usage scenario, exclusions, and error behavior. No redundant or extraneous 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 the tool's simplicity (one parameter, clear annotations, presence of output schema), the description covers everything needed: input format, output example, error handling, and safety guarantees. It is fully self-contained and leaves no important gaps.

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% for the single parameter 'domain'. The description adds meaning beyond the schema: it explains that a full URL is accepted and reduced to its host, and that hostnames resolving to private/internal addresses are refused. This helps the agent correctly format input and anticipate validation failures.

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

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

The description opens with a clear, specific verb+resource combination: 'Score a public domain against 21 agent-readiness checks.' It immediately distinguishes itself from sibling tools by explicitly stating what it is not for (audit_mcp_config, injection_scan). This leaves no ambiguity about the tool's purpose.

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

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

The description provides explicit usage guidance: 'Use when you need to know whether an autonomous agent can discover, read, use or pay a website.' It also gives clear negative examples ('Not for auditing an MCP client configuration... not for scanning text for injection') and includes retry safety advice, making it easy for an agent to decide when to invoke this tool.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds critical behavioral details: 'It never echoes any matched secret value back', it returns error objects instead of protocol errors, and every call is read-only and idempotent. These details are valuable for safe invocation and are not present in the annotations alone.

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

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

The description is approximately 150 words, well-structured, and every sentence serves a purpose. It starts with the core action, lists what the tool checks, provides an input/output example, gives usage guidance, and ends with error behavior. No redundant or fluff 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?

Given the tool's single parameter, the description fully covers input format, output structure, error handling, safety guarantees, and differentiates from related tools. The output schema is described in the text, and the annotations complement the behavioral aspects. It is complete and leaves no obvious gaps.

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

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

The input schema already describes the parameter well (100% coverage). The description adds a concrete example of the typical input format and outlines the response structure, which helps the agent understand usage. While not essential, this extra context justifies a score above the baseline of 3.

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 audits an MCP server config for risk-ranked posture findings. It specifies what it flags (credentials, optional inputs, unpinned versions, etc.) and explicitly differentiates from sibling tools like audit_skill_file and injection_scan. This makes the purpose distinct and 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 explicitly states when to use ('Use on a server configuration document') and when not to ('Not for a skill or instruction file' and 'not for untrusted content'). It also explains error handling behavior and that retrying is safe after correcting input. This provides clear contextual guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false. The description reinforces these and adds important behavioral details: errors never raise protocol errors but return an error object with remediation advice. This adds value beyond annotations and discloses error handling behavior. Could be slightly higher if it mentioned rate limits or quota, but it's solid.

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

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

The description is well-structured: purpose first, then checks, then input/output example, then usage guidance, then error handling. It front-loads key information. While relatively long, every sentence adds value and flows logically. A minor trim could improve conciseness, but it is efficient for the information density.

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 simple schema (1 param), rich annotations (readOnly, idempotent), existence of an output schema, and sibling tool list, the description covers all necessary aspects: purpose, input format, output verdict/findings, error handling, usage boundaries, and safety profiles. No gaps remain for an agent to misunderstand.

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 baseline is 3. The description adds an example JSON input ({"content": "<text>"}) which clarifies the expected format and typical usage. This provides concrete context beyond the schema's text description. No excess; adds meaning.

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 'Audit' and the resource 'agent skill or instruction file'. It specifies what it checks (governance smells like prompt injection, guardrail bypass, etc.) and distinguishes itself from sibling 'injection_scan' by noting it is for pre-trust auditing, not runtime input. Very specific and differentiated.

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 before trusting a skill or instruction file that came from outside your own repository' and 'Not for arbitrary untrusted input at run time (injection_scan)'. This provides clear when-to-use and when-not-to-use guidance, including naming the alternative tool.

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

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

Annotations already declare read-only, idempotent, non-destructive, so the description's main additions are the error-return convention ('never raises a protocol error — it returns {"error": ...}') and the note about retrying safely. This goes beyond the structured annotations to describe failure behavior, which is valuable 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 moderately long but every sentence carries functional information from purpose to error handling. The persona characterization ('allergic to 'it's probably fine'') is slightly stylistic but earns its place by conveying expected audit tone. Overall well-structured with clear paragraphs.

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-argument tool with rich annotations, the description covers purpose, usage boundaries, return shape, and error behavior. It also clarifies licensing ('PREMIUM') and safety properties. Nothing essential is missing for an agent to invoke and interpret results.

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?

Takes zero parameters, and the description explicitly states 'Takes no arguments.' With no schema properties to explain, baseline for 0-param tools is 4, and the description confirms the absence without ambiguity.

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 'Load the Governance Auditor persona for consistent fleet audits' with a specific verb+resource. Explicitly distinguishes from audit tools via 'Not for running an audit - the audit tools do that.' Clear purpose.

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

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

Explicitly says 'Use to keep repeated audits consistent in voice and rigor' and 'Not for running an audit - the audit tools do that,' providing both when-to-use and when-not-to-use guidance. Also identifies alternative tool category.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds beyond these by stating 'Every call is read-only and idempotent, so after correcting the input it is always safe to retry' and detailing the error response format ('never raises a protocol error — it returns {"error": ...}'). This provides extra behavioral context not present in annotations.

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

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

The description is structured with clear sections: purpose, premium note, coverage, example, usage guidance, error handling, and safety. It is front-loaded with the main action and every sentence adds value. 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 complexity (generating a policy document), the description covers input, output format, error handling, retry safety, and when to use. The existence of an output schema is noted in context, and the description explains the output shape. It is fully self-contained and leaves no ambiguity.

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% and the schema already describes the parameter well. The description adds value by providing an example input and showing the output structure, which helps the agent understand how to use the parameter effectively. This goes beyond the baseline of 3.

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 specific verb and resource: 'Generate an audit-ready agent-governance policy for a fleet.' It also distinguishes from siblings by stating that it is not for assessing current fleet state (inventory_report, audit_mcp_config). The purpose is unmistakable.

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

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

Explicitly says 'Use when a fleet needs a written policy document' and provides clear alternatives: 'Not for assessing what the fleet currently does (inventory_report, audit_mcp_config).' It also describes error handling behavior and retry safety, giving the agent a complete usage guide.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint. The description adds further context: error handling (never raises protocol error, returns error object), idempotency and safety to retry, and the exact output structure. No contradictions.

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 paragraph with clear front-loading: purpose first, then usage context, then typical input/output, then distinctions, then error handling, then reassurance. Every sentence adds value with no redundancy.

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

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

Covers what it does, when to use, when not, output fields (injection_suspected, count, hits, note), error behavior, idempotency, and safety guarantees. With a single parameter and thorough annotations, the description is fully self-contained and leaves no open questions.

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% with a clear parameter description. The tool description adds a concrete example of typical input JSON, which helps the agent understand how to structure the parameter value. This goes slightly beyond the schema alone.

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 scans untrusted text for prompt-injection patterns before ingestion, using a specific verb and resource. It differentiates from sibling tool audit_skill_file by explicitly saying what it is not for.

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 states when to use (on web pages, emails, documents before ingestion) and when not to use (not for reviewing a skill file you control, referencing audit_skill_file). Also qualifies that a clean result is not a safety guarantee.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint. The description adds further behavioral context: it never raises protocol errors, returns an error object with fix instructions, and is read-only and idempotent. This goes beyond annotations to fully inform the agent.

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, front-loading the purpose and then providing usage, error handling, and output format. It is slightly verbose but every sentence adds value, earning a high score. Slight deduction for length but still very effective.

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 parameter, straightforward output), the description covers all necessary aspects: input format, output structure, error behavior, usage context, and sibling differentiation. It is completely adequate for an agent to select and invoke the tool correctly.

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

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

The input schema has 100% coverage for the single parameter 'items'. The description adds substantial value by providing a typical input example, explaining the format (JSON array or newline-separated), and linking it to the output structure. This goes well beyond the schema 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 clearly states the verb 'build' and the resource 'governance inventory with risk tiers'. It explicitly distinguishes from siblings by naming 'audit_mcp_config' and 'scope_check' for single-agent auditing, making the tool's scope unambiguous.

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

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

The description explicitly says 'Use to turn a raw agent list into risk tiers' and 'Not for auditing any single agent in depth (audit_mcp_config, scope_check)'. It also provides error handling guidance, stating the tool is safe to retry after correcting input.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description reinforces these traits and adds valuable behavioral context: error handling behavior ('never raises a protocol error — it returns an error object'), and the safety of retrying after correcting input. This goes beyond the annotations.

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

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

The description is well-structured with front-loaded purpose, clear sections, and no wasted words. It is slightly longer than necessary due to the example and error handling details, but every sentence adds value. A minor trim could improve 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?

Given the tool's simplicity (1 parameter, good annotations, output schema exists), the description covers all essential aspects: purpose, input format, output structure (mentioning keys), error behavior, and usage guidelines. No gaps are evident.

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?

Although schema coverage is 100% for the single parameter, the description adds significant meaning: it lists multiple accepted input formats (JSON array, object, newline-separated) and provides a concrete example. This helps the agent construct valid input far beyond the schema's minimal 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 opens with a specific verb+resource: 'Score the blast radius of every tool in a permission manifest.' It clearly states the tool's purpose and distinguishes it from the sibling 'audit_mcp_config' by explicitly saying 'Not for the configuration that mounts them.'

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

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

The description explicitly tells when to use the tool ('Use on a permission manifest to rank tools by blast radius') and when not to use it ('Not for the configuration that mounts them (audit_mcp_config)'). This provides clear guidance for an agent to select the correct tool among siblings.

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