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

No annotations are provided, so the description carries the burden. The verb '获取' implies a read-only operation, and the description lists what content is returned. However, it does not explicitly disclose permissions, error behavior, or side effects, though for a simple getter this is a minor 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 sentence that front-loads the main purpose, lists the returned content, and ends with a usage clause. No wasted words or redundant 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 low-complexity read tool with one parameter and no output schema, the description is sufficient: it explains what is returned, the use case, and the parameter example is in the schema. It does not need to explain return shape because the constituent parts are listed.

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 has one parameter 'name' with a description and examples, giving 100% schema description coverage. The tool description does not add parameter-specific details, but none are needed given the schema already documents the parameter adequately.

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 '获取一个 Skill 的完整定义' specifying the verb and resource, then enumerates the returned components (CoSTAR 背景、目标、风格、语气、受众、规则、示例和 Instructions 正文). This clearly distinguishes it from siblings like soloflow_run_skill or soloflow_list_skills.

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 when to use it: '当你需要了解某个 Skill 的详细内容时使用' (use when you need to understand a Skill's detailed contents). It does not explicitly mention exclusions or alternatives, but the use case is clear.

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 describes the listing action and return fields, but does not explicitly state that the operation is read-only, non-destructive, or what side effects (if any) may occur. The behavior is implied by 'list', but not fully 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?

The description is a single, clear, front-loaded sentence that directly states the action and returned data. Every word earns its place, with no unnecessary details or repetition.

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

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

The tool is simple (no params, no output schema) and the description adequately covers what is returned (agent name, description, bound Skill, personality). It does not explain the list format or whether agents are paginated, but for a basic list tool this is acceptable.

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

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

The tool has zero parameters, so the description does not need to explain parameter semantics. According to the rubric, a baseline of 4 is appropriate when there are no parameters, and the description adds no harmful 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?

The description clearly states the tool lists all available SoloFlow Agent agents and specifies the returned fields (name, description, bound Skill, personality settings). This distinguishes it from sibling tools like soloflow_list_skills, which list skills instead of agents.

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

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

The description implies the tool is used to discover available agents, but it does not explicitly state when to use this tool vs alternatives (e.g., soloflow_list_skills for skills). No exclusionary guidance is provided, though the resource type (Agents) is clear enough.

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 disclose behavioral traits. It states the tool lists flows and returns specific fields, implying a read-only operation. However, it does not explicitly confirm safety, lack of side effects, or any limitations (e.g., pagination). For a simple list operation, this is adequate but not richly transparent.

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, focused sentence in Chinese that states both the action and the output. It is front-loaded with the primary purpose and contains no filler or redundant details.

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

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

For a zero-parameter listing tool with no output schema, the description fully covers the necessary context: it identifies the resource type, scope (all), and the fields returned. No additional context is needed for correct 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?

The tool has zero parameters, and schema coverage is 100%. The description does not need to explain parameters. The schema already shows an empty properties object, and the description's mention of return fields adds clarity without duplicating parameter info. Baseline for 0 params is 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 clearly states 'list all available SoloFlow Flow workflows' with a specific verb ('list') and resource ('Flow workflows'). It also enumerates the return fields (name, version, step count, description), which distinguishes it from sibling tools like soloflow_list_skills and soloflow_list_agents.

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: it returns all flows, so an agent knows when to use this tool (to enumerate available flows). It does not explicitly mention alternatives or exclusions, but the purpose inherently separates it from run/validate tools, so it meets the 'clear context' level.

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

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

Since no annotations are provided, the description carries full responsibility. It states the read-only nature via the verb '列出' (list) and specifies the return fields (name, version, description), giving agents a concrete expectation of the output. It does not mention edge cases like empty lists or pagination, but the simple scope is adequately 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?

The description is two concise Chinese sentences, front-loaded with the action and resource, followed by the return value. Every word serves a purpose with no filler.

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

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

The tool is extremely simple with no parameters and no output schema. The description covers both the operation ('list all available skills') and the return value structure (name, version, description), making it complete for this low 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?

The input schema has zero parameters, so a baseline of 4 is appropriate. The description adds no parameter details because there are none, and it fully covers any parameter semantics by imposing none.

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 the specific verb '列出' (list) and clearly identifies the resource '所有可用的 SoloFlow Skill' (all available SoloFlow Skills). This clearly distinguishes it from sibling tools like soloflow_get_skill (which retrieves one skill) and soloflow_run_skill (which executes a skill).

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 that this tool is for enumerating all available skills, which implies its use for skill discovery. However, it does not explicitly mention alternatives or exclusions (e.g., 'use get_skill for a specific skill'), so it lacks explicit when-not 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?

With no annotations, the description carries the burden of behavioral disclosure. It does reveal the internal process (loading Skills, injecting role settings, executing the task), but it omits any details about return values, side effects, or potential errors. This is partial 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 tight two-sentence explanation that front-loads the core action and includes a useful behavioral note. No redundant information or 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 run tool with no output schema and no annotations, the description is incomplete. It explains the execution process but doesn't mention what the tool returns or any post-execution behavior, which is essential for an agent to know. The lack of output schema makes this a significant gap.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not add any new meaning beyond the schema; it doesn't elaborate on the format or constraints of 'task' or 'agent', relying solely on the schema's parameter 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 clearly states the tool's function: '让一个 Agent 执行任务' (let an Agent execute a task), with the specific resource being an Agent. It also adds distinct context by explaining that the Agent loads its bound Skills and injects role settings, which differentiates it from sibling tools like run_skill or run_flow.

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

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

The description implies the use case (running an agent) but provides no explicit guidance on when to use this tool versus alternatives like run_skill or run_flow. There is no mention of exclusions or scenarios where a different tool would be preferred.

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 discloses that running a Flow involves DAG orchestration and supports dry_run (which implies it may otherwise call LLMs). However, it doesn't mention side effects like actual execution results, potential costs, or return value behavior, leaving some ambiguity for an 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 two concise sentences, front-loaded with the primary purpose. It efficiently conveys the essential behavioral model (DAG, parallel/serial) and dry_run support with 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 there is no output schema, the description should explain what the tool returns, but it does not. It also omits prerequisites (e.g., the flow should already exist or be validated) and whether execution is synchronous or long-running. This is a significant gap for a run tool with no annotations.

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 no significant parameter semantics beyond the schema; it only reiterates the dry_run preview concept already documented. The schema itself provides adequate descriptions for name, inputs, and dry_run.

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 executes a Flow workflow (执行一个 Flow 工作流), using a specific verb and resource. It distinguishes from sibling tools like list_flows and validate_flow by focusing on running, and adds detail about DAG orchestration and parallel/serial execution.

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 when to use this tool: to execute a Flow, with details about how it handles parallel and serial steps. It doesn't explicitly mention alternatives or exclusions, but the context is sufficient for an agent to infer the appropriate use case.

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 burden. It discloses that the Skill follows its CoSTAR framework to guide AI output and supports gacha mode. However, it does not mention side effects, permissions, return format, or whether the operation is asynchronous, leaving some behavioral ambiguity for a run/execute 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 long, front-loaded with the primary purpose, and every sentence adds value. It is efficiently structured and avoids 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?

For a tool with 3 parameters, no annotations, and no output schema, the description covers the core purpose, the CoSTAR framework behavior, and the gacha mode. It does not explain return values explicitly, but the mention of 'AI 输出' implies output. It is reasonably complete for a run tool, though it could benefit from mentioning prerequisites or alternatives.

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 all three parameters (skill, task, count), so the schema already documents them. The description adds marginal value by explaining '抽卡模式' relates to count, but it does not provide deeper semantics beyond what the schema already states.

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+resource: '使用指定的 Skill 执行一个任务' (Execute a task using a specified Skill), which distinguishes it from sibling tools like run_flow and run_agent by focusing on Skills. It also adds specific context about CoSTAR and gacha mode, making the purpose 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 gives clear context for when to use this tool: when you have a Skill and want to execute a task. It implies the need for a named Skill and mentions the optional gacha mode for multiple versions. However, it does not explicitly name alternatives (e.g., run_flow for flows) or state when not to use it.

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

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

No annotations are provided, so the description bears full responsibility. It discloses the core behaviors: checking DAG structure, circular dependencies, step references, and returning validation results plus topological hierarchy. It implies a non-destructive validation operation, though it could be more explicit about being read-only.

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 sentences, front-loading the purpose and stating the return value. There is no redundant information, making it highly 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?

Given the tool's simplicity (one parameter, no output schema, no annotations), the description covers all necessary context: what it validates, the specific checks, and what it returns. It is fully sufficient for an agent to understand and invoke the 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?

The only parameter 'name' is fully described in the schema (Flow 名称), so schema coverage is 100%. The description does not add any additional semantic meaning beyond what the schema already provides, so the baseline 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 the tool validates a Flow file, specifying the exact checks (DAG structure, circular dependencies, step references) and the return value (validation result and topological hierarchy). It explicitly distinguishes this from the sibling tool soloflow_validate_skill.

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 clearly implies when to use it (when you need to validate a Flow file) but does not explicitly contrast it with alternatives like soloflow_validate_skill or state when not to use it. Still, the context is clear and not misleading.

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 of behavioral disclosure. It only says 'validate format completeness', which is a restatement of purpose. It does not state whether the operation is read-only, what happens on invalid input, whether it returns detailed errors, or any side effects. This is a significant gap for a validation tool without 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 a single, front-loaded sentence with no unnecessary words. It conveys the core purpose efficiently without 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?

The tool is simple (1 parameter, no output schema), but the description does not explain return values or validation outcomes. The agent cannot infer whether validation returns a boolean, a report, or throws an exception. Missing output semantics and usage context make the description incomplete.

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 'name' (described as 'Skill 名称'). The description adds no additional meaning beyond the schema, so the baseline 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 the action ('validate') and the resource ('Skill file'), and specifies the focus ('format completeness'). It distinguishes itself from sibling tools like 'soloflow_get_skill' and 'soloflow_run_skill' by focusing on validation, and from 'soloflow_validate_flow' by targeting skills rather than flows.

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

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

The description implies usage: use this tool to check a Skill file's format completeness. However, it does not explicitly state when to use it versus alternatives (e.g., 'use this before running a skill' or 'use soloflow_validate_flow for flows'). No exclusions or prerequisites are mentioned.

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