rapp-agent-builder

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so safety is covered. The description adds real value beyond that by disclosing the exact rule set checked (manifest, naming, class, perform method, secrets) and that the tool emits a report of findings the agent should act on.

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, zero filler, and the most important content (what it validates) is front-loaded before the workflow instruction. Every clause 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?

For a read-only validator with full annotation and parameter coverage and no output schema, the description supplies what rules are checked and how to react to findings. It could be slightly more explicit about the shape of the report, but nothing essential for correct invocation is missing.

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%, with both parameters ('code', 'filename') fully documented including the _agent.py naming convention. The description adds no parameter 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?

States a specific verb and resource ('Checks a finished RAPP agent file') and enumerates exactly what is validated: manifest, naming, class, perform method, hardcoded secrets. This distinguishes it clearly from siblings like get_agent_code or get_agent_template.

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

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

Gives explicit prescriptive guidance: 'Call it on every agent you write, fix anything it reports, and call it again until it passes,' which covers the intended workflow and iteration loop. No explicit when-not-to-use or named alternative is provided, so it falls short of a 5.

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=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds useful non-schema context: the corpus is public, external, and roughly 1,700 single-file agents, which tells the agent about recall and coverage limits. It does not discuss result ranking or pagination, so it stops short of a 5.

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

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

Two sentences with zero filler, and the most decision-relevant fact (what registry, how big) is front-loaded ahead of the usage conditions.

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?

Complete enough for a two-parameter discovery tool whose annotations carry the safety profile. The only mild gap is that, with no output schema present, it does not describe what a returned result looks like beyond 'agents that already do what the user wants'.

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 both the query and limit parameters (including default and max) are already fully documented in the schema. The description adds no syntax, format, or filtering guidance beyond that, 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?

States a specific verb (Searches) plus a precisely scoped resource (the public RAPP Agent Registry, ~1,700 single-file agents) and the user intent it serves. An agent can tell this apart from siblings like check_agent or get_agent_code, which operate on a specific agent rather than discovering one.

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?

Explicit when-to-use is given: 'Use it before building from scratch, or when the user asks whether an agent exists for a task,' reinforced by the sample user phrasing 'is there an AI tool for...'. No explicit when-not or named alternative is stated, but the trigger conditions are unambiguous.

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=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description usefully adds that the whole source is returned rather than metadata, but says nothing about behavior when the name is unknown or about any size limits.

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?

One sentence with zero waste, front-loading the return value and the lookup key before the supporting example. Nothing needs trimming.

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 carries the burden of describing the return, and 'full source' covers it adequately for a single-parameter read tool. Minor gaps are error behavior and whether output is raw text or structured.

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 single 'name' parameter is fully documented in the schema with an example. The description's parenthetical example (@bill/neuron_agent) reinforces the format but adds no semantics beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource (returns the full source of one agent from the registry), names the lookup key (its name), and gives the exact identifier format. An agent can tell this apart from get_agent_template and check_agent without opening any schema.

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

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

The phrase 'so it can be read or adapted' implies the use case but never states when to choose this over siblings like get_agent_template, find_agents, or check_agent. Guidance is implied rather than explicit, with no 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 readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so safety is covered. The description adds genuinely useful behavioral context beyond that: the return is a single-file template with rules, the agent must author the content itself, and there is a mandatory validation step via check_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?

Front-loaded with the usage condition and examples, then the return value, then the follow-up sequence. The parenthetical example list is somewhat long but each item clarifies scope rather than padding.

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?

No output schema exists, but the description explains what comes back (a single-file template plus its rules) and how it should be used downstream, which is exactly what an agent needs for a zero-parameter, read-only fetch.

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 takes zero parameters, so the baseline is 4; there is no parameter syntax to document and the description correctly spends no words on 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?

States a specific verb and resource ('Returns the official single-file RAPP agent template and its rules') and frames the trigger scenarios (idea, repetitive task, process description, meeting transcript) that separate it from siblings like find_agents or get_agent_code.

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?

Explicit when-to-use triggers with concrete examples, plus an explicit workflow: fill in the template yourself, then call check_agent before showing it, then call use_agent_here. Names the alternative tools and the ordering, leaving nothing to inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe, non-mutating, non-open-world action. The description adds that it is informational and references the external 'RAPP Brainstem' product, which is useful context, but does not describe the output form. With annotations carrying the safety profile, this is adequate but not rich.

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 filler, and the usage condition is front-loaded ('Optional, for later'). Efficient, though the second sentence slightly restates the timing already implied by 'for later'.

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 informational helper with no output schema and fully documented parameters, the description supplies everything an agent needs: what it explains, that it is optional/later, and the exact conversational precondition for offering it.

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

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

Schema description coverage is 100% and both parameters (os, filename) are documented in the schema, so the description need not explain them. The description adds nothing about os or filename, so the baseline 3 applies.

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

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

States a specific action (explaining how to keep an agent running) on a specific resource (the user's own computer via the RAPP Brainstem). This is distinguishable from siblings like use_agent_here (running in chat) and get_agent_code, though it never names those alternatives to sharpen the contrast.

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

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

Gives an explicit precondition and timing: 'Optional, for later' and 'Only offer this after the user has used the agent in the chat and wants to keep it.' That is clear when-to-offer guidance. It does not name alternative tools or a when-not condition, so it stops short of a 5.

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 declare a non-read-only, non-destructive, closed-world write, and the description adds meaningful context beyond that: only the request text is stored, no name or contact data, and user consent must be obtained first. It stops short of describing what happens after the request is recorded or any confirmation behavior.

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

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

Three short sentences, front-loaded with the usage condition, then the privacy scope, then the consent gate. Nothing is redundant and every sentence carries actionable information.

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

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

For a single-parameter write tool with no output schema, the description covers trigger, consent, and data scope adequately. Only minor gaps remain, such as what the agent should do if the person says no or what happens after the request is recorded.

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 single parameter's description already says 'as they agreed to send it.' The description's phrasing mirrors that constraint rather than adding format, length, or fidelity details beyond the schema, so baseline 3 applies.

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

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

The description states the tool records a request the person agrees to send, which is a specific verb+resource, and implicitly distinguishes it from siblings by framing it as the fallback when none of 'these tools' can fulfill the need. It is clear, though the purpose is conveyed through usage framing rather than a direct statement.

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 gives the trigger condition ('wants something none of these tools can do and says yes to passing the request on') and a prerequisite ('Ask before calling it'). The agent knows exactly when to invoke it and what consent gate must be cleared 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?

With annotations only covering the safety profile (readOnlyHint/destructiveHint/openWorldHint), the description supplies the substantive behavior: it scans for emails, phone numbers, and secrets, explains publishing to a public registry under the user's GitHub account, and explicitly states 'Nothing is published by this tool.' That last clause reinforces rather than contradicts the readOnly annotation.

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 sentences, front-loaded with the usage trigger followed by process and outcome. Every sentence carries information, though the middle sentence is dense with three separate behaviors.

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 two-parameter tool with no output schema, the description covers the trigger, the processing behavior, and the outcome, and clarifies no external side effect occurs. What the scan report actually returns is left implicit, but the annotations and schema carry the rest.

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 filename and code are already documented in the schema. The description adds nothing about the parameters (no format hints, no relationship between code and filename), so the baseline 3 applies.

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

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

The description states a specific verb and resource ('share an agent'), and clarifies the actual behavior: it scans the agent for personal details and explains publishing steps rather than performing a publish. It distinguishes itself by trigger condition, though it never names the overlapping sibling check_agent explicitly.

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 opening clause 'Use only when the user says they want to share an agent they built' gives an explicit, restrictive trigger that separates this from check_agent and find_agents. It does not name alternative tools or say when not to use it beyond that single condition.

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=true, destructiveHint=false, openWorldHint=false, so the safety profile is covered and the description does not contradict it. The description adds real behavioral context beyond the annotations: what is returned (a short Python runner), that nothing needs installing, and the no-Python fallback. It omits execution/return-format details of the runner itself, so not a 5.

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

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

The description is front-loaded with the primary trigger and the primary outcome, then adds the fallback instruction. Sentences are dense but each carries information; the 'Ask the user for their real data, run the agent, and show the result' sentence is slightly prescriptive/duplicative but still actionable.

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 optional parameter, full schema coverage, no output schema, and annotations covering the safety profile, the description covers what an agent needs: when to invoke, what it returns, and what to do without Python. Naming the sibling check_agent as the upstream step closes the main routing gap; only the exact usage of the returned runner is left implicit.

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

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

There is only one parameter (filename) and schema description coverage is 100%, so the schema already documents its meaning and expected format ('invoice_triage_agent.py'). The description adds no further semantics about the filename (e.g. where it comes from or whether it must match the checked agent), 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 states a specific outcome: it 'Returns a short Python runner so you can run the agent in this chat with your own Python tool on the user's own data.' This clearly distinguishes it from siblings like check_agent and get_agent_code by naming the concrete artifact returned. It stops short of a 5 because the verb ('use') is generic and the differentiation from get_agent_code/how_to_run_agent is only implied.

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 triggering conditions ('right after an agent passes check_agent, or whenever the user wants to try an agent') and names check_agent as the upstream step. It also supplies a fallback path ('If Python is unavailable, apply the agent's logic yourself'). No explicit 'do not use this when...' exclusion against other siblings, so not a 5.

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