TrustyCap

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

The annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds meaningful behavioral context by detailing what the returned artifact includes and how the customization contract classifies surfaces, which helps the agent understand the scope and safe boundaries without repeating annotation 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 dense but purposeful, front-loading the main deliverable and contents in the first sentence. The later sentences justify why the tool should be read before code changes and explain the contract's role, so each sentence earns its place despite the length.

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, the description compensates by enumerating the returned components: workflow, capability calls, human stops, cost, checklist, and contract. It also explains the purpose and trust boundaries, giving an agent enough context 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 schema already provides 100% parameter coverage with an example value ('vehicle-finance'), so the description does not need to add much. It reinforces that the tool targets a single Launch Kit, but it does not add new semantics beyond the schema.

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

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

The description clearly states the tool returns 'the full starting point for one Launch Kit' and enumerates its contents: workflow, capabilities, human stops, cost, checklist, and customization contract. This distinguishes it from sibling list tools like trustycap_list_launch_kits by emphasizing 'one Launch Kit' rather than a collection.

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 explicit usage context: 'Read this before writing or changing code against a kit.' This tells the agent when the tool is relevant, though it does not explicitly name alternatives or state when not to use it beyond the implied contrast with listing kits or native kits.

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 establish read-only, idempotent, non-destructive behavior. The description meaningfully adds content-level context by enumerating exactly what is returned—hashes, pinned dependencies, permissions, plist keys, human-in-the-loop install steps, and constraints—without contradicting 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 opening phrase is a strong front-loaded summary. The rest is one long colon-driven enumeration that would scan more easily as bullets or short sentences, but each listed item carries specific, non-redundant 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 one fully documented parameter and no output schema, the description carries the burden of explaining what the agent will get, and it does so exhaustively: files, hashes, dependencies, permissions, install steps, evidence, and constraints. It also tells the agent when to consult the result, making the definition complete 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 single 'id' parameter has 100% schema description coverage, including an example. The description adds no parameter-level meaning beyond what the schema already provides, so the baseline 3 is appropriate.

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

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

The description opens with a specific resource ('one Native Kit') and an outcome ('install without reverse-engineering'), and the promised contents—files, hashes, dependencies, permissions, install steps—clearly distinguish this from list-oriented siblings like trustycap_list_native_kits and get_launch_kit.

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?

'Read this before touching a native project' provides a clear, concrete usage context, and the focus on installing one Native Kit implies it is for detailed single-kit prep rather than discovery. It does not explicitly name alternatives 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?

The description adds a strong behavioral guarantee beyond the annotations: it is deterministic, grounded only in the published registry and rate card, and cannot invent capabilities, kits, or prices. This is valuable safety and reliability context that the readOnly/idempotent annotations do not fully convey.

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?

Three focused sentences with no filler. Each sentence adds a distinct, useful fact: the output summary, the use condition, and the deterministic behavior. The description is front-loaded with the tool's core action and does not repeat schema or annotation 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 read-only tool with one required parameter and no output schema, the description is nearly sufficient: it enumerates the response content, the input, the use case, and behavioral constraints. It could be slightly more explicit about exact response shape or no-match handling, but nothing essential is missing 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?

Schema coverage is 100%, so the baseline is 3. The description enriches the intent parameter by explaining what happens with it (returns matching kits, reasons, costs, plan) and clarifies launch_kit's role as a way to plan directly without recommendation, though the schema already describes launch_kit 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 names a concrete flow: take the human's own words, return matching Launch Kits/capabilities, reason for each match, unit cost, and an actionable build plan. It also contrasts with capability-driven tools ('rather than which capability they want'), distinguishing it from sibling tools.

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 the tool: when the user expresses what they want to build instead of naming a specific capability. It gives clear context for choosing it over capability-selection tools, though it does not name specific alternative tools or provide explicit 'do not use when' 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?

Annotations already declare readOnly, idempotent, and non-destructive. The description adds meaningful behavioral detail beyond that: it says the tool returns every public capability and lists exactly what information is included (purpose, selection guidance, non-goals, scopes, meters, price). This helps the agent set expectations without contradicting 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 front-loaded with the core purpose and includes a direct call-to-action. It is somewhat dense due to long enumerations of problem areas and family names, but each sentence contributes information and there is no filler.

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

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

With no output schema, the description compensates by detailing the returned fields (purpose, when to choose, non-guarantees, scopes, meters, price). It also covers the major functional families and provides a 'call before assuming' heuristic. The optional family filter is handled by the schema. This is sufficient for an agent to select and call 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?

Schema description coverage is 100%, so the family parameter is fully documented in the schema, including accepted neutral names and canonical ids. The tool description adds no extra parameter semantics, but the baseline of 3 applies because the schema carries the weight.

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 verb-resource pair ('Find the TrustyCap capability') and enumerates concrete problem areas (secure storage, background work, scheduling, webhooks, credentials, email, documents, payments). It explicitly says it returns every public capability with its purpose, scopes, meters, and price, making it distinct from the sibling list-kit and guide tools.

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 an explicit trigger: 'Call this before assuming a capability exists.' It also implies this is the discovery entry point for capability lookup. It does not name sibling alternatives or state when not to use them, but the context is clear enough for an agent to route to this tool first.

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 non-destructive behavior, so the description does not need to restate those. It adds valuable behavioral context beyond annotations: each kit specifies capability ordering, cost per unit, and what the builder still owns. The explicit statement that a Launch Kit is a starting point, not a finished product, clarifies expectations and prevents misuse.

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 appropriately sized — four sentences, each adding distinct value. The core purpose is front-loaded, usage guidance appears mid-way, and caveats about ownership are succinct. There is no filler or repetition of information already present in the title or annotations.

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 empty input schema, the read-only annotations, and the presence of sibling tools like trustycap_get_launch_kit and trustycap_list_native_kits, the description provides enough context for an agent to select this tool correctly. It explains what a Launch Kit is, when to use it, what information it conveys, and what it does not provide. The lack of an output schema is partly mitigated by describing the contents of each kit.

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 parameter-level semantics are inherently not a concern. The description compensates by explaining what the listed kits contain and what one unit costs to run, giving the agent useful context for interpreting the result. This exceeds the baseline for a no-parameter tool.

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 purpose: listing TrustyCap Launch Kits, defined as proven backend compositions a builder can start a business from. It distinguishes this from single-operation tools by emphasizing business-level scope. The verb 'List' and resource 'Launch Kits' are specific and match the tool name and title.

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 explicit when-to-use guidance: 'Use this when someone describes a business they want to build rather than a single operation they want performed.' It also frames the Backend Launch Kit as the default answer for production readiness. It does not name specific alternative tools, but the contrast between whole-business and single-operation is a clear enough steering signal.

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 non-destructive behavior, so the bar is lower. The description adds valuable context: kits are 'cut from TrustyCap products where it runs in production' and 'licensed per production application and free in test mode and development builds.' This goes beyond the structured annotations without contradicting them.

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 longer than strictly necessary but every sentence earns its place: scope, definition, usage, and licensing. It front-loads 'Native work that is already finished' before expanding into context. Slightly verbose but well-organized.

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 0-parameter, read-only list tool with no output schema, the description covers what the tool lists, when to use it, and licensing implications. It doesn't explicitly describe the response format, but the title and sibling tools make the list semantics inferable.

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 the input schema is empty, so the baseline is 4. The description adds no parameter-specific meaning, but none is needed. The schema fully covers the absent 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?

The title 'List TrustyCap Native Kits' plus the description 'Native work that is already finished' clearly identifies the verb (list) and resource (Native Kits). It also distinguishes Native Kits from capabilities ('A capability is something TrustyCap performs when you ask; a Native Kit is packaged iOS and Android source...'), so an agent can tell it apart from sibling tools like trustycap_list_capabilities.

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 explicit usage guidance: 'Use this when the problem is on the device rather than on the server' followed by concrete device-side examples. It does not name an alternative tool directly, but the capability-vs-kit contrast implies when the other listing tool might apply.

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 indicate read-only, idempotent, and non-destructive behavior, and the description aligns with this by describing the tool as answering questions and providing evidence rather than performing actions. It also discloses what the tool will not do by saying what TrustyCap is not for, making behavior fully 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 information-dense but not bloated; every sentence and clause adds useful guidance about when to use the tool, what it answers, and what it does not cover. The structure is logical, moving from trigger conditions to decision outputs to limitations.

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 absence of parameters and output schema, the description fully covers the necessary context: when to call, what decision is made, what information is provided, what is excluded, and prerequisites. It leaves no missing context an agent would need to use 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 tool has no parameters, and the schema coverage is 100%, so there are no parameter semantics to document. The description does not introduce any implicit parameters or inputs, making this dimension trivially complete.

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 this tool is the entry point for production-readiness decisions, specifying when to use it and exactly what decision it answers. It directly addresses whether TrustyCap fits and which option to install, leaving no ambiguity about its 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 explicitly instructs to call this tool before installing anything and states that no credential is needed, providing clear usage conditions. It also frames the tool as a decision aid for choosing among options, which implicitly guides the agent on when to invoke it.

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